{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d84ef532",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "from sympy.abc import x,y,m,n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "7096d07c",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=Piecewise(((x+1)**2,x<1),(4-sqrt(x-1),True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f9c93b90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} \\left(x + 1\\right)^{2} & \\text{for}\\: x < 1 \\\\4 - \\sqrt{x - 1} & \\text{otherwise} \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise(((x + 1)**2, x < 1), (4 - sqrt(x - 1), True))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "19d3c4ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, -2\\right] \\cup \\left[0, 10\\right]$"
      ],
      "text/plain": [
       "Union(Interval(-oo, -2), Interval(0, 10))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr>=1,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "34e963d1",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Equality in module sympy.core.relational:\n",
      "\n",
      "class Equality(Relational)\n",
      " |  Equality(lhs, rhs=None, **options)\n",
      " |  \n",
      " |  An equal relation between two objects.\n",
      " |  \n",
      " |  Explanation\n",
      " |  ===========\n",
      " |  \n",
      " |  Represents that two objects are equal.  If they can be easily shown\n",
      " |  to be definitively equal (or unequal), this will reduce to True (or\n",
      " |  False).  Otherwise, the relation is maintained as an unevaluated\n",
      " |  Equality object.  Use the ``simplify`` function on this object for\n",
      " |  more nontrivial evaluation of the equality relation.\n",
      " |  \n",
      " |  As usual, the keyword argument ``evaluate=False`` can be used to\n",
      " |  prevent any evaluation.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Eq, simplify, exp, cos\n",
      " |  >>> from sympy.abc import x, y\n",
      " |  >>> Eq(y, x + x**2)\n",
      " |  Eq(y, x**2 + x)\n",
      " |  >>> Eq(2, 5)\n",
      " |  False\n",
      " |  >>> Eq(2, 5, evaluate=False)\n",
      " |  Eq(2, 5)\n",
      " |  >>> _.doit()\n",
      " |  False\n",
      " |  >>> Eq(exp(x), exp(x).rewrite(cos))\n",
      " |  Eq(exp(x), sinh(x) + cosh(x))\n",
      " |  >>> simplify(_)\n",
      " |  True\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  sympy.logic.boolalg.Equivalent : for representing equality between two\n",
      " |      boolean expressions\n",
      " |  \n",
      " |  Notes\n",
      " |  =====\n",
      " |  \n",
      " |  Python treats 1 and True (and 0 and False) as being equal; SymPy\n",
      " |  does not. And integer will always compare as unequal to a Boolean:\n",
      " |  \n",
      " |  >>> Eq(True, 1), True == 1\n",
      " |  (False, True)\n",
      " |  \n",
      " |  This class is not the same as the == operator.  The == operator tests\n",
      " |  for exact structural equality between two expressions; this class\n",
      " |  compares expressions mathematically.\n",
      " |  \n",
      " |  If either object defines an ``_eval_Eq`` method, it can be used in place of\n",
      " |  the default algorithm.  If ``lhs._eval_Eq(rhs)`` or ``rhs._eval_Eq(lhs)``\n",
      " |  returns anything other than None, that return value will be substituted for\n",
      " |  the Equality.  If None is returned by ``_eval_Eq``, an Equality object will\n",
      " |  be created as usual.\n",
      " |  \n",
      " |  Since this object is already an expression, it does not respond to\n",
      " |  the method ``as_expr`` if one tries to create `x - y` from ``Eq(x, y)``.\n",
      " |  This can be done with the ``rewrite(Add)`` method.\n",
      " |  \n",
      " |  .. deprecated:: 1.5\n",
      " |  \n",
      " |     ``Eq(expr)`` with a single argument is a shorthand for ``Eq(expr, 0)``,\n",
      " |     but this behavior is deprecated and will be removed in a future version\n",
      " |     of SymPy.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Equality\n",
      " |      Relational\n",
      " |      sympy.logic.boolalg.Boolean\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  as_poly(self, *gens, **kwargs)\n",
      " |      Returns lhs-rhs as a Poly\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Eq(x**2, 1).as_poly(x)\n",
      " |      Poly(x**2 - 1, x, domain='ZZ')\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, lhs, rhs=None, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  binary_symbols\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  is_Equality = True\n",
      " |  \n",
      " |  rel_op = '=='\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Relational:\n",
      " |  \n",
      " |  __bool__(self)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if the sides of the relationship are mathematically\n",
      " |      identical and the type of relationship is the same.\n",
      " |      If failing_expression is True, return the expression whose truth value\n",
      " |      was unknown.\n",
      " |  \n",
      " |  expand(self, **kwargs)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from Relational:\n",
      " |  \n",
      " |  canonical\n",
      " |      Return a canonical form of the relational by putting a\n",
      " |      number on the rhs, canonically removing a sign or else\n",
      " |      ordering the args canonically. No other simplification is\n",
      " |      attempted.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x < 2\n",
      " |      x < 2\n",
      " |      >>> _.reversed.canonical\n",
      " |      x < 2\n",
      " |      >>> (-y < x).canonical\n",
      " |      x > -y\n",
      " |      >>> (-y > x).canonical\n",
      " |      x < -y\n",
      " |      >>> (-y < -x).canonical\n",
      " |      x < y\n",
      " |      \n",
      " |      The canonicalization is recursively applied:\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> Eq(x < y, y > x).canonical\n",
      " |      True\n",
      " |  \n",
      " |  lhs\n",
      " |      The left-hand side of the relation.\n",
      " |  \n",
      " |  negated\n",
      " |      Return the negated relationship.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Eq(x, 1)\n",
      " |      Eq(x, 1)\n",
      " |      >>> _.negated\n",
      " |      Ne(x, 1)\n",
      " |      >>> x < 1\n",
      " |      x < 1\n",
      " |      >>> _.negated\n",
      " |      x >= 1\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This works more or less identical to ``~``/``Not``. The difference is\n",
      " |      that ``negated`` returns the relationship even if ``evaluate=False``.\n",
      " |      Hence, this is useful in code when checking for e.g. negated relations\n",
      " |      to existing ones as it will not be affected by the `evaluate` flag.\n",
      " |  \n",
      " |  reversed\n",
      " |      Return the relationship with sides reversed.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Eq(x, 1)\n",
      " |      Eq(x, 1)\n",
      " |      >>> _.reversed\n",
      " |      Eq(1, x)\n",
      " |      >>> x < 1\n",
      " |      x < 1\n",
      " |      >>> _.reversed\n",
      " |      1 > x\n",
      " |  \n",
      " |  reversedsign\n",
      " |      Return the relationship with signs reversed.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Eq(x, 1)\n",
      " |      Eq(x, 1)\n",
      " |      >>> _.reversedsign\n",
      " |      Eq(-x, -1)\n",
      " |      >>> x < 1\n",
      " |      x < 1\n",
      " |      >>> _.reversedsign\n",
      " |      -x > -1\n",
      " |  \n",
      " |  rhs\n",
      " |      The right-hand side of the relation.\n",
      " |  \n",
      " |  strict\n",
      " |      return the strict version of the inequality or self\n",
      " |      \n",
      " |      EXAMPLES\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (x <= 1).strict\n",
      " |      x < 1\n",
      " |      >>> _.strict\n",
      " |      x < 1\n",
      " |  \n",
      " |  weak\n",
      " |      return the non-strict version of the inequality or self\n",
      " |      \n",
      " |      EXAMPLES\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (x < 1).weak\n",
      " |      x <= 1\n",
      " |      >>> _.weak\n",
      " |      x <= 1\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Relational:\n",
      " |  \n",
      " |  ValidRelationOperator = {None: <class 'sympy.core.relational.Equality'...\n",
      " |  \n",
      " |  is_Relational = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.logic.boolalg.Boolean:\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __invert__(self)\n",
      " |      Overloading for ~\n",
      " |  \n",
      " |  __lshift__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |  \n",
      " |  __rand__ = __and__(self, other)\n",
      " |  \n",
      " |  __rlshift__ = __rshift__(self, other)\n",
      " |  \n",
      " |  __ror__ = __or__(self, other)\n",
      " |  \n",
      " |  __rrshift__ = __lshift__(self, other)\n",
      " |  \n",
      " |  __rshift__(self, other)\n",
      " |  \n",
      " |  __rxor__ = __xor__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  as_set(self)\n",
      " |      Rewrites Boolean expression in terms of real sets.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Eq, Or, And\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> Eq(x, 0).as_set()\n",
      " |      {0}\n",
      " |      >>> (x > 0).as_set()\n",
      " |      Interval.open(0, oo)\n",
      " |      >>> And(-2 < x, x < 2).as_set()\n",
      " |      Interval.open(-2, 2)\n",
      " |      >>> Or(x < -2, 2 < x).as_set()\n",
      " |      Union(Interval.open(-oo, -2), Interval.open(2, oo))\n",
      " |  \n",
      " |  to_nnf(self, simplify=True)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.logic.boolalg.Boolean:\n",
      " |  \n",
      " |  kind = BooleanKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> int\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself doesn't match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace doesn't differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Don't override .args() from Basic (so that it's easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'Tuple[Basic, ...]', '_mhash': 'Any', 'kin...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Eq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "61dcf8de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x \\neq 1$"
      ],
      "text/plain": [
       "Ne(x, 1)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ne(x,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "cf3813c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, -1\\right) \\cup \\left(-1, 1\\right) \\cup \\left(1, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, -1), Interval.open(-1, 1), Interval.open(1, oo))"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(Ne(x**2,1),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "44f25436",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "3df35281",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.calculus.util import continuous_domain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "164f2a25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 0\\right) \\cup \\left(0, 1\\right]$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, 0), Interval.Lopen(0, 1))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "continuous_domain(1/x+sqrt(1-x),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "95c59563",
   "metadata": {},
   "outputs": [],
   "source": [
    "r=symbols(\"r\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "227801f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(r in Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e7fdecca",
   "metadata": {},
   "outputs": [],
   "source": [
    "f=Function(\"f\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "74d104c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.function.UndefinedFunction"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "839877a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f{\\left(x - 1 \\right)} + f{\\left(x + 1 \\right)} = 2.5 f{\\left(x \\right)}$"
      ],
      "text/plain": [
       "Eq(f(x - 1) + f(x + 1), 2.5*f(x))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(f(x+1)+f(x-1),(5/2)*f(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "a6914c0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{\\cos^{2}{\\left(x \\right)}}$"
      ],
      "text/plain": [
       "cos(x)**(-2)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/(cos(x))**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "0cc194be",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{x\\; \\middle|\\; x > 0 \\right\\}$"
      ],
      "text/plain": [
       "ConditionSet(x, x > 0)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ConditionSet(x,x>0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "7ce72892",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "3b317ae2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/home/huang/python_code',\n",
       " '/home/huang/anaconda3/lib/python39.zip',\n",
       " '/home/huang/anaconda3/lib/python3.9',\n",
       " '/home/huang/anaconda3/lib/python3.9/lib-dynload',\n",
       " '',\n",
       " '/home/huang/anaconda3/lib/python3.9/site-packages']"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "3336aba2",
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append(\"/home/huang/Documents/packaging_tutorial/src\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "1ae5cc9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/home/huang/python_code',\n",
       " '/home/huang/anaconda3/lib/python39.zip',\n",
       " '/home/huang/anaconda3/lib/python3.9',\n",
       " '/home/huang/anaconda3/lib/python3.9/lib-dynload',\n",
       " '',\n",
       " '/home/huang/anaconda3/lib/python3.9/site-packages',\n",
       " '/home/huang/Documents/packaging_tutorial/src']"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "23a1097c",
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport function_calculator_package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "a31aef6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from function_calculator_package.extreme_points import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "44bd094a",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=x*(1-ln(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "a4232484",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'+': [Interval.open(0, 1)], '-': [Interval.open(1, oo)]}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_monotonyset(expr,x,Interval.open(0,oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "75163a4f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(1073741793 \\right)}}{\\log{\\left(2 \\right)}}$"
      ],
      "text/plain": [
       "log(1073741793)/log(2)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(2**30-29-2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "1e75faf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "d=symbols(\"d\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "6efcf027",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( \\frac{d}{2}, \\  \\frac{d}{2}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(d/2, d/2)}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linsolve([Eq(x+d-2*y,x+2*d-4*y),Eq(x+d-2*y,8*y-(x+3*d))],[x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "ef261770",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(n, m)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n,m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "25361cb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 258$"
      ],
      "text/plain": [
       "258"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summation(m*2**m,(m,1,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "c2fdc92c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(-1\\right)^{n}}{2} + \\frac{3^{n}}{2}$"
      ],
      "text/plain": [
       "(-1)**n/2 + 3**n/2"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsolve(f(n+2)-2*f(n+1)-3*f(n),f(n),{f(1):1,f(2):5})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "476757ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test=[4,3]\n",
    "test.extend([1,2,3])\n",
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "84a9a367",
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def list_0_1(a:list,n:int)->list:\n",
    "    \"\"\"\n",
    "        The first arg should be 0-1 list.\n",
    "    \"\"\"\n",
    "    if(n<=0):\n",
    "        return a\n",
    "    else:\n",
    "        answer=[]\n",
    "        for i in range(n):\n",
    "            for item in a:\n",
    "                if(item==0):\n",
    "                    answer.extend([1,0,1])\n",
    "                elif(item==1):\n",
    "                    answer.extend([0,1,0])\n",
    "                else:\n",
    "                    raise  SyntaxError\n",
    "            a=answer\n",
    "            answer=[]\n",
    "        return a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "771291fe",
   "metadata": {},
   "source": [
    "**计算机算不出来，内核聪明的挂断。**\n",
    "sum(list_0_1([0,1,0],2021))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ab8e2d6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2^{m + 5} m$"
      ],
      "text/plain": [
       "2**(m + 5)*m"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(summation(4*(n+1)*2**(n+2),(n,1,m)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2d0fce1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_expr=Eq(x**2/4+y**2,1).subs(x,m*y-Rational(6,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "13221f18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle m^{2} y^{2} - \\frac{12 m y}{5} + 4 y^{2} - \\frac{64}{25}$"
      ],
      "text/plain": [
       "m**2*y**2 - 12*m*y/5 + 4*y**2 - 64/25"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((new_expr.lhs-new_expr.rhs)*4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c4adf0b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=2*cos(2*x-pi/6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "06e8f67f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "KeyboardInterrupt\n",
      "\n"
     ]
    }
   ],
   "source": [
    "solveset((expr-expr.subs(x,-7*pi/4))*(expr-expr.subs(x,4*pi/3))>0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3b9ced07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,4*pi/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8d8475da",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,-7*pi/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e0ecfd98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,5*pi/6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "820e76e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(0, \\pi\\right)$"
      ],
      "text/plain": [
       "Interval.open(0, pi)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(sin(x)>0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "614ddf82",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=2*sin(2*x-pi/6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "31fb622d",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7f4f5fa6fa60>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,-17*pi/12,-2*pi/3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "ad52562b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 24$"
      ],
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "65a0c594",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6$"
      ],
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d303b0ba",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class FallingFactorial in module sympy.functions.combinatorial.factorials:\n",
      "\n",
      "class FallingFactorial(CombinatorialFunction)\n",
      " |  FallingFactorial(x, k)\n",
      " |  \n",
      " |  Falling factorial (related to rising factorial) is a double valued\n",
      " |  function arising in concrete mathematics, hypergeometric functions\n",
      " |  and series expansions. It is defined by\n",
      " |  \n",
      " |  .. math:: ff(x,k) = x \\cdot (x-1) \\cdots (x-k+1)\n",
      " |  \n",
      " |  where `x` can be arbitrary expression and `k` is an integer. For\n",
      " |  more information check \"Concrete mathematics\" by Graham, pp. 66\n",
      " |  or visit http://mathworld.wolfram.com/FallingFactorial.html page.\n",
      " |  \n",
      " |  When `x` is a Poly instance of degree >= 1 with single variable,\n",
      " |  `ff(x,k) = x(y) \\cdot x(y-1) \\cdots x(y-k+1)`, where `y` is the\n",
      " |  variable of `x`. This is as described in Peter Paule, \"Greatest\n",
      " |  Factorial Factorization and Symbolic Summation\", Journal of\n",
      " |  Symbolic Computation, vol. 20, pp. 235-268, 1995.\n",
      " |  \n",
      " |  >>> from sympy import ff, Poly, Symbol\n",
      " |  >>> from sympy.abc import x\n",
      " |  >>> n = Symbol('n', integer=True)\n",
      " |  \n",
      " |  >>> ff(x, 0)\n",
      " |  1\n",
      " |  >>> ff(5, 5)\n",
      " |  120\n",
      " |  >>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)\n",
      " |  True\n",
      " |  >>> ff(Poly(x**2, x), 2)\n",
      " |  Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ')\n",
      " |  >>> ff(n, n)\n",
      " |  factorial(n)\n",
      " |  \n",
      " |  Rewriting is complicated unless the relationship between\n",
      " |  the arguments is known, but falling factorial can\n",
      " |  be rewritten in terms of gamma, factorial and binomial\n",
      " |  and rising factorial.\n",
      " |  \n",
      " |  >>> from sympy import factorial, rf, gamma, binomial, Symbol\n",
      " |  >>> n = Symbol('n', integer=True, positive=True)\n",
      " |  >>> F = ff(n, n - 2)\n",
      " |  >>> for i in (rf, ff, factorial, binomial, gamma):\n",
      " |  ...  F.rewrite(i)\n",
      " |  ...\n",
      " |  RisingFactorial(3, n - 2)\n",
      " |  FallingFactorial(n, n - 2)\n",
      " |  factorial(n)/2\n",
      " |  binomial(n, n - 2)*factorial(n - 2)\n",
      " |  gamma(n + 1)/2\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  factorial, factorial2, RisingFactorial\n",
      " |  \n",
      " |  References\n",
      " |  ==========\n",
      " |  \n",
      " |  .. [1] http://mathworld.wolfram.com/FallingFactorial.html\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      FallingFactorial\n",
      " |      CombinatorialFunction\n",
      " |      sympy.core.function.Function\n",
      " |      sympy.core.function.Application\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  eval(x, k) from sympy.core.function.FunctionClass\n",
      " |      Returns a canonical form of cls applied to arguments args.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The eval() method is called when the class cls is about to be\n",
      " |      instantiated and it should return either some simplified instance\n",
      " |      (possible of some other class), or if the class cls should be\n",
      " |      unmodified, return None.\n",
      " |      \n",
      " |      Examples of eval() for the function \"sign\"\n",
      " |      ---------------------------------------------\n",
      " |      \n",
      " |      .. code-block:: python\n",
      " |      \n",
      " |          @classmethod\n",
      " |          def eval(cls, arg):\n",
      " |              if arg is S.NaN:\n",
      " |                  return S.NaN\n",
      " |              if arg.is_zero: return S.Zero\n",
      " |              if arg.is_positive: return S.One\n",
      " |              if arg.is_negative: return S.NegativeOne\n",
      " |              if isinstance(arg, Mul):\n",
      " |                  coeff, terms = arg.as_coeff_Mul(rational=True)\n",
      " |                  if coeff is not S.One:\n",
      " |                      return cls(coeff) * cls(terms)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  as_base_exp(self)\n",
      " |      Returns the method as the 2-tuple (base, exponent).\n",
      " |  \n",
      " |  fdiff(self, argindex=1)\n",
      " |      Returns the first derivative of the function.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  class_key() from sympy.core.function.FunctionClass\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  is_singular(a) from sympy.core.function.FunctionClass\n",
      " |      Tests whether the argument is an essential singularity\n",
      " |      or a branch point, or the functions is non-holomorphic.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  __new__(cls, *args, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  is_Function = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __abs__(self)\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None)\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_coeff_add(self, *deps)\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |      \n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |      \n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |  \n",
      " |  as_coeff_exponent(self, x)\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, **kwargs)\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0. If an expression is\n",
      " |      not an Add it is considered to have a single term.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |      \n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |      \n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |      \n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |      \n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |      \n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |      \n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |      \n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |      \n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |      \n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |      \n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint)\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      .separatevars(), .expand(log=True), sympy.core.add.Add.as_two_terms(),\n",
      " |      sympy.core.mul.Mul.as_two_terms(), .as_coeff_add(), .as_coeff_mul()\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      expression -> a/b -> a, b\n",
      " |      \n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Performs complex expansion on 'self' and returns a tuple\n",
      " |      containing collected both real and imaginary parts. This\n",
      " |      method cannot be confused with re() and im() functions,\n",
      " |      which does not perform complex expansion at evaluation.\n",
      " |      \n",
      " |      However it is possible to expand both re() and im()\n",
      " |      functions and get exactly the same results as with\n",
      " |      a single call to this function.\n",
      " |      \n",
      " |      >>> from sympy import symbols, I\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> (x + y*I).as_real_imag()\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> from sympy.abc import z, w\n",
      " |      \n",
      " |      >>> (z + w*I).as_real_imag()\n",
      " |      (re(z) - im(w), re(w) + im(z))\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The number of terms upto which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] http://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it doesn't, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      is_rational_function()\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but gives only an Order term\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      O(log(x)**2)\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The number of terms upto which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |      \n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |      \n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |      \n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |      \n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |      \n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |      \n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> int\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself doesn't match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace lambda rule, **_\n",
      " |      # Function needs args so we define a property that returns\n",
      " |      # a function that takes args...and then use that function\n",
      " |      # to return the right value\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.function.FunctionClass\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Don't override .args() from Basic (so that it's easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'Tuple[Basic, ...]', '_mhash': 'Any', 'kin...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  kind = UndefinedKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(ff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "b5e3cedb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-1\\right)^{n} \\left(m - 1\\right) + \\left(m - 1\\right)^{n}$"
      ],
      "text/plain": [
       "(-1)**n*(m - 1) + (m - 1)**n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsolve(f(n+1)-f(n)*(m-2)-(m-1)*f(n-1),f(n),{f(2):ff(m,2),f(3):ff(m,3)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "737274ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 165$"
      ],
      "text/plain": [
       "165"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(11,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5015329e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 432$"
      ],
      "text/plain": [
       "432"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ff(4,4)*binomial(4,2)*binomial(3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "a5bff579",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{7} - 8 x^{5} + 20 x^{3} - \\frac{80}{x} + \\frac{128}{x^{3}} - \\frac{64}{x^{5}}$"
      ],
      "text/plain": [
       "x**7 - 8*x**5 + 20*x**3 - 80/x + 128/x**3 - 64/x**5"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((x**2+2)*(x-2/x)**5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "b5b24ade",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{7} - x^{6} + 12 x^{5} - 12 x^{4} + 60 x^{3} - 60 x^{2} + 160 x - 160 + \\frac{240}{x} - \\frac{240}{x^{2}} + \\frac{192}{x^{3}} - \\frac{192}{x^{4}} + \\frac{64}{x^{5}} - \\frac{64}{x^{6}}$"
      ],
      "text/plain": [
       "x**7 - x**6 + 12*x**5 - 12*x**4 + 60*x**3 - 60*x**2 + 160*x - 160 + 240/x - 240/x**2 + 192/x**3 - 192/x**4 + 64/x**5 - 64/x**6"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((x-1)*(x+2/x)**6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "612f3c07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 64 x^{6} + 128 x^{5} - 80 x^{4} + 20 x^{2} - 8 x + 1$"
      ],
      "text/plain": [
       "-64*x**6 + 128*x**5 - 80*x**4 + 20*x**2 - 8*x + 1"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((2*x+1)*(1-2*x)**5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1b43b2f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "253e36e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{5} + 7 x^{4} + 20 x^{3} + 30 x^{2} + 25 x + 11 + \\frac{2}{x}$"
      ],
      "text/plain": [
       "x**5 + 7*x**4 + 20*x**3 + 30*x**2 + 25*x + 11 + 2/x"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((2/x+1)*(x+1)**5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "49e80dcd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{15} + 10 x^{10} + 40 x^{5} + 80 + \\frac{80}{x^{5}} + \\frac{32}{x^{10}}$"
      ],
      "text/plain": [
       "x**15 + 10*x**10 + 40*x**5 + 80 + 80/x**5 + 32/x**10"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((x**3+2/x**2)**5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "cded7ae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "1f27631d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{5} - 5 a^{4} b x + 10 a^{3} b^{2} x^{2} - 10 a^{2} b^{3} x^{3} + 5 a b^{4} x^{4} - b^{5} x^{5}$"
      ],
      "text/plain": [
       "a**5 - 5*a**4*b*x + 10*a**3*b**2*x**2 - 10*a**2*b**3*x**3 + 5*a*b**4*x**4 - b**5*x**5"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((a-b*x)**5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "fb651ef9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - x^{5} + 5 x^{4} - 5 x^{3} - 10 x^{2} + 15 x + 11 - \\frac{15}{x} - \\frac{10}{x^{2}} + \\frac{5}{x^{3}} + \\frac{5}{x^{4}} + \\frac{1}{x^{5}}$"
      ],
      "text/plain": [
       "-x**5 + 5*x**4 - 5*x**3 - 10*x**2 + 15*x + 11 - 15/x - 10/x**2 + 5/x**3 + 5/x**4 + x**(-5)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((1+1/x-x)**5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "33ffb8c6",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7f4f4d30bcd0>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot((1+1/x-x)**5,(x,0.25,0.4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "0913eb9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.111605$"
      ],
      "text/plain": [
       "0.111605000000000"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(0.1)*(1+0.11+0.11**2/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "05fcba11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 210$"
      ],
      "text/plain": [
       "210"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(10,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "9ed9a8ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1}{2} - \\frac{\\sqrt{3}}{6}, \\frac{\\sqrt{3}}{6} + \\frac{1}{2}\\right\\}$"
      ],
      "text/plain": [
       "{1/2 - sqrt(3)/6, sqrt(3)/6 + 1/2}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(-6*x**2+6*x-1,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "66a0e015",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "9916772b",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=-2*p**3+3*p**2-p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "0436a848",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAAHWCAYAAAAciQ/OAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABrV0lEQVR4nO3de1xUdcIG8GdmgOEijCB3RS5eAO8KycVrpZhpVyvLstxN023N27qV2W7WbvnattWaqWVaVt4qs6zMpPIuoCJ4RQUBQWW4ygzXGWbmvH+MTBGogMCZM/N8P5/5vHk4Z87Dzis8/s45v59MEAQBRERERCRJcrEDEBEREVHrscwRERERSRjLHBEREZGEscwRERERSRjLHBEREZGEscwRERERSRjLHBEREZGEscwRERERSRjLXAcRBAFarRaco5mIiIjaEstcB6moqIBKpUJFRYXYUYiIiMiGsMwRERERSRjLHBEREZGEscwRERERSRjLHBEREZGEscwRERERSRjLHBEREZGEscwRERERSZjkytzKlSsRGhoKZ2dnREVFYf/+/dfdt6CgAFOmTEF4eDjkcjnmzZvX5H5bt25Fnz59oFQq0adPH2zbtu2WzktERETUUSRV5rZs2YJ58+Zh8eLFSEtLw4gRIzB+/Hjk5eU1ub9Op4OPjw8WL16MgQMHNrlPUlISJk+ejKlTp+L48eOYOnUqHnnkEaSkpLT6vEREREQdRSZIaH2pmJgYDBkyBKtWrbJsi4yMxP3334+lS5fe8NjRo0dj0KBBePfddxtsnzx5MrRaLX788UfLtrvuuguenp7YtGnTLZ+3nlarhUqlgkajgYeHR7OOISIiIroZyYzM6fV6pKamIiEhocH2hIQEHDp0qNXvm5SU1Og9x40bZ3nP1p5Xp9NBq9U2eBERERG1NcmUuZKSEhiNRvj5+TXY7ufnB7Va3er3VavVN3zP1p536dKlUKlUlldQUFCrMxIRERFdj2TKXD2ZTNbgz4IgNNrWHu/Z0vMuWrQIGo3G8srPz7+ljERERERNcRA7QHN5e3tDoVA0Gg0rKipqNGrWEv7+/jd8z9aeV6lUQqlUtjoXERERUXNIZmTOyckJUVFRSExMbLA9MTER8fHxrX7fuLi4Ru+5a9cuy3u213mJiIiI2oJkRuYAYMGCBZg6dSqio6MRFxeHDz/8EHl5eZg1axYA86XNy5cv49NPP7Uck56eDgCorKxEcXEx0tPT4eTkhD59+gAA5s6di5EjR2LZsmW477778O233+Lnn3/GgQMHmn1eIiIiIrFIqsxNnjwZpaWleO2111BQUIB+/fphx44dCA4OBmCeJPiPc78NHjzY8t+pqanYuHEjgoODkZubCwCIj4/H5s2b8fLLL+Mf//gHevTogS1btiAmJqbZ5yUiIiISi6TmmZMsQYC2VA2VTyA0xVc4zxwREZEtcHQFbvEhzLYgqZE5yaqrBv4bbv7v/4YDSvE/eCIiIrpFL10BnNzETiGdByCIiIiIqDFeZu0IvMxKRGR36owmnLykQWpeOY5dLENaXjk0tXUN9pHLgIgAD3RVucBgEmA0mWA0CTCaYP6zIEBvMCGzqAJ6g8lynEwG9OvaGcN6dMGwHt4YGKSCo4LjMx3OSi6zssx1EK7NSkRkH2rrjPjiaD4+2JuNy+U1Db7m4qjA4O6dER3ihdtCPDG4uyc6KW9+x1NtnRGHc8qwP7MY+86X4FxhRYOvd1I6YEykL+bc2QthPp3a9Psh68cy10FY5oiIbFulzoDPky/io/05KKnUAQA6uzoiNrQLokM8cVuIF/oEerTJCFqhthb7M0uw73wxDmSVoKxKDwBQyGWYfFsQ5t7ZC34ezrd8HpIGlrkOwjJHRGSbrlbp8cmhXHxyKBeaGvNl1K6dXTBzVBgeiQ6Cs6OiXc9vMgk4fqkcK37Nwi9niwAAzo5y/GlYKGaN7AGVq2O7np/ExzLXQVjmiIhsS5G2Fh8dyMHnyRdRrTcCAMK83fCX0T1w/+CuotzDdiS3DP/341mkXrwKAFC5OOIvo3tgWnxIu5dKEg/LXAdhmSMisg0Gowkf7s/G/37OhO7aQwmRAR6YfXtP3NXPHwq5uDfEC4KAXzKK8OZPZ3G+sBIAEKhyxntThiAq2FPUbNQ+WOY6CMscEZH0nS+swN+/PI7jlzQAgCHdO2P2HT1xe7gvZFbwVOPvGU0CtqVdxjuJ53G5vAaOChlentAHT8YFW11WujUscx2EZY6ISLoMRhM+2GcejdMbTXB3dsAr9/TFpCFdrb4YVeoMeOGrE/jhZAEA4P5BgXjjwf5wdeK6AbaCZa6DsMwREUnT+cIKLPzyOE5cG427I8IXbzzQH/4q6TwtKggC1h7IwdIfz8JoEhDu547VU6MQ6i3+6gV061jmOgjLHBGRtAiCgE8O5WLpjrPQG03wcHbAknv74oHB1j8adz0p2aX468Y0lFTq4K50wFuPDMS4vv5ix6JbxDLXQVjmiIikQ28w4Z/fnsLmI/kAgDsjfPHGg/1tYu62Qm0t/rrhGI5ee+J11qgeWJjQGw5cQUKyWOY6CMscEZE0lFbq8JfPj+FwbhnkMuCluyPx9PBQyY7GNaXOaMLSHWex7mAOACChjx/ef3wIlwSTKJa5DsIyR0Rk/c6qtZi+/iguXa2Bu9IBy6cMxu3hvmLHajffHb+Cv315HHqDCRMHBOB/jw4WfWoVajk+ykJERAQg8Uwh5m1OQ5XeiJAurvjoqWj09HUXO1a7umdgIDopHfDMZ0fx/YkCODnI8dZDAyFnoZMUjqcSEZFdEwQBq/ZcwDOfHUWV3oj4Hl3wzV+H2XyRq3d7hC/ee2wIFHIZvj52GS9/ewq8aCctLHNERGS39AYT/vbFcSzbeRaCAEyNDcb6Pw9FZ1cnsaN1qLv6+ePtRwZCJgM2puThX99nsNBJCC+zEhGRXdIZjPjrhjT8nFEIhVyGJff0wdS4ELFjiea+QV2hM5jw/FcnsO5gDpwd5fj7uHCbevDDVrHMERGR3dEZjPjL58fw69kiKB3k+GBqFEbb8IMOzfVIdBB0dUb849vTWLnnApwdFZhzZy+xY9FN8DIrERHZldo6I2Z9lmopcmufuo1F7nemxoXg5QmRAIC3E8/jo/3ZIieim2GZIyIiu1FbZ8TMz1Kx+1wxnB3l+HjabRjey1vsWFZn+ogwLEzoDQB4fUcG9mcWi5yIboRljoiI7EJtnREzPj2KveeL4eKowMfThiK+J4vc9cy+oxceGxoEQQDmbU5HobZW7Eh0HSxzRERk82r0Rjy9/gj2Z5bA1UmBj/90G+J6dBE7ltV75Z6+iAzwQGmVHs9tSoPBaBI7EjWBZY6IiGxabZ25yB3MKoWrkwKf/GkoYsNY5JrD2VGB96cMhpuTAodzyvDOz+fFjkRNYJkjIiKbZTQJmLMpDYculMLNSYFP/zwUQ0O9xI4lKWE+nfB/kwYAAN7ffQG7zxWJnIj+iGWOiIhskiAIWLL9NHadKYSTQo51025DdAiLXGvcMzAQT8R2BwAs2JKOK+U1Iiei32OZIyIim7Rq7wV8lnwRMhnwzuRBiOGl1Vvy8oQ+6BvogavVdXhuUxrqeP+c1WCZIyIim/P1sUt4c+c5AMA/JvTBhAEBIieSPmdHBVY+PgTuSgekXryKt346J3YkuoZljoiIbMqBzBI8/9UJAMCMEaH48/BQkRPZjuAubnjzIfP9cx/sy8YvGYUiJyKAZY6IiGzImStazPo8FQaTgHsGBmLR+EixI9mc8f0DMC0+BACw4IvjuHS1WtxAxDJHRES24XJ5Df70yWFU6gyIDfPCWw8PgFzOReLbw6K7IzCwmwqamjr8dWMa9AbePycmljkiIpK8Gr0Rz3x6FIVaHcL93PHB1GgoHRRix7JZSgcFVkwZAg9nBxzPL8d7v2aKHcmuscwREZGkCYKARV+fwOkrWnRxc8K6P90GlYuj2LFsXpCXK5Y+aL5/bvXeC8gqqhQ5kf1imSMiIklbeyAH36RfgUIuw4opQ9C1s4vYkezG3f39cUeEL+qMAl7+5iQEQRA7kl1imSMiIsk6mFWCpT+eBQD8Y0Ik11vtYDKZDK/e2xfOjnIkZ5dhW9plsSPZJZY5IiKSpPyyaszeeAxGk4BJQ7rhqWtPWFLHCvJyxZw7ewEAXv8hA+XVepET2R+WOSIikpwavREzP0vF1eo6DOimwusP9INMxidXxTJ9eBh6+XZCaZUey3aeFTuO3WGZIyIiSREEAS9sPYEzBVp4d3LC6iei4OzIJ1fF5OQgx7/v7wcA2HQ4H6kXy0ROZF9Y5oiISFLWHsjB9uNX4CCX4f0pQxDIBx6sQkxYFzwc1Q0AsHjbKa7d2oFY5oiISDLS88vxf9ceeHh5QiRiwvjAgzVZdHckPF0dcVZdgY8P5ogdx26wzBERkSRoa+swZ1MaDCYBE/oH8IEHK+Tl5oRFd5uXUHsnMROXy2tETmQfJFfmVq5cidDQUDg7OyMqKgr79++/4f579+5FVFQUnJ2dERYWhtWrVzf4+ujRoyGTyRq9JkyYYNlnyZIljb7u7+/fLt8fERE1JggCXvr6JPLKqtHN0wVvPNifDzxYqYeGdMPQEC/U1BmxZPtpsePYBUmVuS1btmDevHlYvHgx0tLSMGLECIwfPx55eXlN7p+Tk4O7774bI0aMQFpaGl566SXMmTMHW7dutezz9ddfo6CgwPI6deoUFAoFHn744Qbv1bdv3wb7nTx5sl2/VyIi+s0XR/Px/YkCKOQyLH9sMFd4sGJyuQz/fqAfHOQyJJ4pxO6zRWJHsnmSKnNvv/02nn76aUyfPh2RkZF49913ERQUhFWrVjW5/+rVq9G9e3e8++67iIyMxPTp0/HnP/8Zb731lmUfLy8v+Pv7W16JiYlwdXVtVOYcHBwa7Ofj49Ou3ysREZllFlbglWsjPAsTwjGku6fIiehmevu540/DQgAA//npHEwmrgzRniRT5vR6PVJTU5GQkNBge0JCAg4dOtTkMUlJSY32HzduHI4ePYq6uromj1m7di0effRRuLm5NdiemZmJwMBAhIaG4tFHH0V2dvYtfDdERNQctXVGPLcpDbV1Jozo5Y2ZI8PEjkTN9OzonuikdMCZAi12nCoQO45Nk0yZKykpgdFohJ+fX4Ptfn5+UKvVTR6jVqub3N9gMKCkpKTR/ocPH8apU6cwffr0BttjYmLw6aef4qeffsKaNWugVqsRHx+P0tLS6+bV6XTQarUNXkRE1DL//uEMzqor4N1JibcfGQS5nPfJSYWnmxOmjwgFALydeB4GTlXSbiRT5ur98YZXQRBueBNsU/s3tR0wj8r169cPQ4cObbB9/PjxmDRpEvr3748xY8bghx9+AACsX7/+uuddunQpVCqV5RUUFHTjb4yIiBr48WQBPk823xP99iMD4eOuFDkRtdTTw0Ph6eqI7OIqfM11W9uNZMqct7c3FApFo1G4oqKiRqNv9fz9/Zvc38HBAV26NJybqLq6Gps3b240KtcUNzc39O/fH5mZmdfdZ9GiRdBoNJZXfn7+Td+XiIjMLpfX4IWtJwAAs0b1wMjevE9ZitydHfGX0T0AAP/7ORM6g1HkRLZJMmXOyckJUVFRSExMbLA9MTER8fHxTR4TFxfXaP9du3YhOjoajo4Nn4T64osvoNPp8MQTT9w0i06nQ0ZGBgICAq67j1KphIeHR4MXERHdnMkk4PmvjkNba8CgoM74W0JvsSPRLXgyLgR+HkpcLq/B5sMc2GgPkilzALBgwQJ89NFHWLduHTIyMjB//nzk5eVh1qxZAMyjYU8++aRl/1mzZuHixYtYsGABMjIysG7dOqxduxYLFy5s9N5r167F/fff32jEDgAWLlyIvXv3IicnBykpKXjooYeg1Wrx1FNPtd83S0RkpzYczsPBrFI4O8rxzuRBcFRI6lcV/YGzowKz7+gFAHjv1yxU6w0iJ7I9DmIHaInJkyejtLQUr732GgoKCtCvXz/s2LEDwcHBAICCgoIGc86FhoZix44dmD9/Pt5//30EBgZi+fLlmDRpUoP3PX/+PA4cOIBdu3Y1ed5Lly7hscceQ0lJCXx8fBAbG4vk5GTLeYmIqG3klVZj6Y4MAMALd0Ug1NvtJkeQFEyODsKH+y4gv6wG6w9dtFx6pbYhE+qfCKB2pdVqoVKpoNFoeMmViKgJJpOAx9YkIyWnDDGhXtg0I5ZPr9qQr49dwoIvjkPl4oh9z9/OiZ/bEMeuiYjIKnyalIuUnDK4Oinwn4cGssjZmPsGdUUv307Q1NRh7X7O1dqWWOaIiEh0OSVV+L+dZwEAi+6ORPcuriInoramkMssD7OsPZCD0kqdyIlsB8scERGJymgS8Pcvj6O2zoRhPbvg8aHdxY5E7WRcX3/076pCld6IVXsuiB3HZrDMERGRqD4+mIOjF6+ik9IByyYN4OVVGyaTybBwXDgA4NPkiyjQ1IicyDawzBERkWiyiirxn5/OAQBenhCJbp68vGrrRvbyxtAQL+gNJrz3a5bYcWwCyxwREYnCYDRh4ZfHoTOYMLK3DybfxmUP7cHvR+e+OJKPi6VVIieSPpY5IiISxZr9OUjPL4e7swOWTep/w3W2ybYMDfXCqN4+MJgErNzNe+duFcscERF1uKyiCryTeB4A8Mo9fRGgchE5EXW0OXf2BABsS7uM4go+2XorWOaIiKhDmUwCXvr6FPRGE+6I8MWkIV3FjkQiGNLdE4OCOkNvNOGz5Itix5E0ljkiIupQX6bm43CueXLgf93fj5dX7ZRMJsOMEWEAgM+TL6K2zihyIulimSMiog5TUqnDGzvMkwMvGNsbXTvz8qo9G9fXD908XVBWpcfWY5fEjiNZLHNERNRhXv8hA5qaOvQJ8MC0+BCx45DIHBRy/GlYKABg7f4cmExcLr41WOaIiKhDHMgswba0y5DLgKUP9oeDgr+CCJh8WxDcnR2QXVKF3eeKxI4jSfybRERE7a62zojF35wEADwZF4KBQZ3FDURWo5PSAVOuLeG2Zn+2yGmkiWWOiIja3Ypfs3CxtBr+Hs6WxdaJ6j0VHwIHuQzJ2WU4dVkjdhzJYZkjIqJ2db6wAh/sM08Mu+TevnB3dhQ5EVmbwM4umDAgAADwEUfnWoxljoiI2o3JJGDxtpOoMwoYE+mHcX39xI5EVqp+mpLvTxSgQFMjchppYZkjIqJ2s+VoPo7kXoWrkwKv3teXc8rRdfXrqkJsmBcMJgGfHMwVO46ksMwREVG7KK3UYemODACcU46aZ/pw8+jcxsN5qNQZRE4jHSxzRETULv7z0zloaw2cU46a7Y4IX4T5uKGi1oAvjuSLHUcyWOaIiKjNnbhUji1Hzb+MX7uvL+eUo2aRy2V4erh5EuF1B3NgMJpETiQN/NtFRERtymQS8M9vT0MQgAcGd0V0iJfYkUhCHhzcDZ6ujrh0tQY/nS4UO44ksMwREVGb2nrsEtLzy+HmpMCi8RFixyGJcXFSYGpsMADg06RcccNIBMscERG1GW1tHZbtPAsAmHNnL/h6OIuciKTosZjukMuAlJwyXCiuFDuO1WOZIyKiNvO/nzNRUqlHmLebZQF1opYKULlgdLgvAGALH4S4KZY5IiJqE5mFFVh/KBcA8M97+sDJgb9iqPUevS0IALA19RL0Bj4IcSP8m0ZERLdMEAQs+e40DCbzSg/1oypErXVHhC983ZUordIj8QwfhLgRljkiIrplP51W42BWKZwc5PjnxD5ixyEb4KCQ4+HobgCAzUfyRE5j3VjmiIjoltTojfjX9+aVHmaODEP3Lq4iJyJbMTm6OwBgf2YJ8suqRU5jvVjmiIjolqzeewGXy2sQqHLGs6N7ih2HbEj3Lq4Y3tMbAB+EuBGWOSIiarX8smqs3nsBALB4Qh+4OClETkS25tGh5gchvkzN54oQ18EyR0RErfZ/O89CZzAhLqwL7u7vL3YcskFj+/jBy80JhVoddp8rFjuOVWKZIyKiVkm9eBU/nCiATAb8Y2IfyGQysSORDVI6KDBpSFcAwObDfBCiKSxzRETUYoIg4N8/nAEAPBzVDX0CPURORLZs8m3mByF2nytCgaZG5DTWh2WOiIha7IeTBUjLK4eLowJ/SwgXOw7ZuJ6+nTA0xAsmAfjy6CWx41gdljkiImoRncFoWX911qge8OP6q9QBHosxPwix5Ug+TCZB5DTWhWWOiIhaZP2hXOSX1cDPQ4kZI7n+KnWM8f0C4OHsgMvlNdifVSJ2HKvCMkdERM1WVqXHe79mAQAWJoTD1clB5ERkL5wdFXhwyLUVIfggRAMsc0RE1GzLf8lERa0BfQI8MOnaL1aijlI/51zimUIUV+hETmM9WOaIiKhZLhRX4vPkiwCAlydEQi7nVCTUsSL8PTAoqDMMJgFbj/FBiHosc0RE1CxLd5yFwSTgzghfxF9bYomooz16m3l07muWOQuWOSIiuqmkC6X4OaMQCrkMi+6OFDsO2bHx/QPgpJDjfGElzqq1YsexCpIrcytXrkRoaCicnZ0RFRWF/fv333D/vXv3IioqCs7OzggLC8Pq1asbfP2TTz6BTCZr9Kqtrb2l8xIR2QqTScDrO8wTBD8e0x09fTuJnIjsmcrFEaPDfQAA29OviJzGOkiqzG3ZsgXz5s3D4sWLkZaWhhEjRmD8+PHIy2v6qZacnBzcfffdGDFiBNLS0vDSSy9hzpw52Lp1a4P9PDw8UFBQ0ODl7PzbvEktPS8RkS3ZlnYZpy5r4a50wNw7e4kdhwj3DgoEAGw/fgWCwDnnZIKE/leIiYnBkCFDsGrVKsu2yMhI3H///Vi6dGmj/V944QVs374dGRkZlm2zZs3C8ePHkZSUBMA8Mjdv3jyUl5e32XmbotVqoVKpoNFo4OHBZW+ISBpq9Ebc/tYeqLW1eHF8BGaN6iF2JCLU6I2I/nciqvRGbP1LPKKCPcWOJCrJjMzp9XqkpqYiISGhwfaEhAQcOnSoyWOSkpIa7T9u3DgcPXoUdXV1lm2VlZUIDg5Gt27dMHHiRKSlpd3SeYmIbMUnh3Kh1taia2cXTIsPETsOEQDAxUmBhL7+AIDt6ZdFTiM+yZS5kpISGI1G+Pn5Ndju5+cHtVrd5DFqtbrJ/Q0GA0pKzLNHR0RE4JNPPsH27duxadMmODs7Y9iwYcjMzGz1eQFAp9NBq9U2eBERSYmmug6r9pgnCP5bQm84OypETkT0m/pLrT+cLIDBaBI5jbgkU+bqyWQN5zUSBKHRtpvt//vtsbGxeOKJJzBw4ECMGDECX3zxBXr37o333nvvls67dOlSqFQqyysoKOjm3xwRkRVZuTcL2loDIvzdcd+grmLHIWpgeE9veLo6oqRSj6TsUrHjiEoyZc7b2xsKhaLRaFhRUVGjUbN6/v7+Te7v4OCALl26NHmMXC7HbbfdZhmZa815AWDRokXQaDSWV35+/k2/RyIia1GgqcEnB3MBAM/fFQ4FJwgmK+OokOPu/gEAgG/t/KlWyZQ5JycnREVFITExscH2xMRExMfHN3lMXFxco/137dqF6OhoODo6NnmMIAhIT09HQEBAq88LAEqlEh4eHg1eRERS8b+fM6EzmHBbiCduD/cVOw5Rk+pHjH86pUZtnVHkNOKRTJkDgAULFuCjjz7CunXrkJGRgfnz5yMvLw+zZs0CYB4Ne/LJJy37z5o1CxcvXsSCBQuQkZGBdevWYe3atVi4cKFln1dffRU//fQTsrOzkZ6ejqeffhrp6emW92zOeYmIbElWUSW+OGq+mvDi+Igb3lJCJKboYE8EqJxRoTNgz7kiseOIxkHsAC0xefJklJaW4rXXXkNBQQH69euHHTt2IDg4GABQUFDQYO630NBQ7NixA/Pnz8f777+PwMBALF++HJMmTbLsU15ejmeeeQZqtRoqlQqDBw/Gvn37MHTo0Gafl4jIlrz10zmYBGBMpB+igr3EjkN0XXK5DPcODMQH+7Kx/fgV3NUvQOxIopDUPHNSxnnmiEgK0vKu4oGVhyCXATvnjURvP3exIxHd0KnLGkx87wCcHORIfXkM3J2bvo3KlknqMisREbUfQRCwbOdZAMCDQ7qxyJEk9A30QJiPG/QGE3adLhQ7jihY5oiICACw93wxkrPL4OQgx/yxvcWOQ9QsMpkM9w00Pwix/bh9PtXKMkdERDCZBCzbeQ4A8GRsMLp2dhE5EVHz1U8gfCCrBKWVOpHTdDyWOSIiwncnriCjQAt3pQP+entPseMQtUiotxsGdFPBaBKw42SB2HE6HMscEZGd0xtM+O+u8wCAmaPC4OnmJHIiopa7d6B5dM4eJxBmmSMisnNbjuQhr6waPu5K/Hl4qNhxiFpl4oBAyGTA0YtXcbm8Ruw4HYpljojIjtXojVj+axYAYM4dPeHqJKnpR4ks/FXOiAk1z4v4nZ09CMEyR0Rkxz5PvojiCh26dnbB5Nu6ix2H6Jbce+2pVnu71MoyR0Rkpyp1BqzaewEAMHdMLzg58FcCSdv4fv5wVMiQUaBFZmGF2HE6DP/mEhHZqY8P5KCsSo8wbzc8OLir2HGIbpmnmxNG9vIBYF+XWlnmiIjskKa6Dh/uzwYAzBvbGw4K/jog2zBxoHl91l1n7Gc1CP7tJSKyQ2v2Z6Oi1oBwP3dM7G+fi5OTbbo93BcKuQxn1RXIL6sWO06HYJkjIrIzpZU6rDuYAwBYkNAbcrlM5EREbaezqxNuC/EEACTayegcyxwRkZ1ZvfcCqvVG9O+qQkIfP7HjELW5MZHm/79mmSMiIptTqK3Fp0kXAQB/S+gNmYyjcmR7xl77R8rh3DJoqutETtP+WOaIiOzIil+zoDOYEB3siVG9fcSOQ9Qugru4obdfJxhNAnafKxI7TrtjmSMishP5ZdXYfCQPALBwXDhH5cim1Y/OJWbY/qVWljkiIjvx3q+ZqDMKGN7TG7FhXcSOQ9Su6u+b23uuGHqDSeQ07YtljojIDuSUVGHrscsAzE+wEtm6gd06w8ddiUqdAcnZpWLHaVcsc0REduB/P5+H0STgjghfDOnuKXYconYnl8swJtIXAPCzjV9qZZkjIrJxWUWV2H5taaMFYzkqR/aj/lLrz2cKIQiCyGnaD8scEZGNe+/XTJgE8w3h/bqqxI5D1GGG9fSGi6MCVzS1OH1FK3acdsMyR0Rkw34/Kjf3zl4ipyHqWM6OCozo5Q3Ati+1sswREdmw5b9kQhCABI7KkZ0a08f2V4NgmSMislFZRRX47sS1UbkxHJUj+3RnhC9kMuD0FS2ulNeIHaddsMwREdmo//2SBUEAxvX1Q99AjsqRferSSYmoa09w2+qlVpY5IiIblFlYge/rR+Xu5BOsZN/G2vilVpY5IiIb9L9r98rd1dcffQI9xI5DJKr6++aSs0tRUVsncpq2xzJHRGRjzhdW4IeTBQB4rxwRAPTw6YQwbzfUGQXsPV8sdpw2xzJHRGRj6kflxvfzR2QAR+WIgN8utf5sg5daWeaIiGzIOXUFdlwblZvDeeWILOovtf56tgh1RpPIadoWyxwRkQ2pn1fu7v4clSP6vSHdPeHl5gRtrQFHcsvEjtOmWOaIiGzEOfVv98pxVI6oIYVchjsifAEAP58pEjlN22KZIyKyEct/yQRgHpWL8OeoHNEfjYm8NkVJhhqCIIicpu2wzBER2YDMwgrsOMVROaIbGdnbG04OcuSX1eB8YaXYcdoMyxwRkQ1Ysfu31R44KkfUNFcnBwzv6Q0ASDyjFjlN22GZIyKSuOziSnx33Lzaw3N3cFSO6EZ+u9RqO/fNscwREUnc+7svwCSYFxTv15VrsBLdyJhI80MQx/PLUaitFTlN22CZIyKSsLzSanyTfhkA8BzvlSO6KV8PZwwM6gwA+MVGRudY5oiIJGzlniwYTQJG9vbBoGu/oIjoxhLqV4PIsI3VIFjmiIgk6tLVamw9dgkAMPfOniKnIZKO+vvmDmSVoEpnEDnNrWOZIyKSqNV7L6DOKCC+RxdEBXuJHYdIMnr7dUKQlwv0BhOSLpSKHeeWSa7MrVy5EqGhoXB2dkZUVBT2799/w/337t2LqKgoODs7IywsDKtXr27w9TVr1mDEiBHw9PSEp6cnxowZg8OHDzfYZ8mSJZDJZA1e/v7+bf69ERE1l1pTiy+OmEflOK8cUcvIZDKM6OUDwDw6J3WSKnNbtmzBvHnzsHjxYqSlpWHEiBEYP3488vLymtw/JycHd999N0aMGIG0tDS89NJLmDNnDrZu3WrZZ8+ePXjsscewe/duJCUloXv37khISMDly5cbvFffvn1RUFBgeZ08ebJdv1ciohtZvfcC9EYThoZ4ITasi9hxiCRnZC/zfHP7MotFTnLrZIKE1rOIiYnBkCFDsGrVKsu2yMhI3H///Vi6dGmj/V944QVs374dGRkZlm2zZs3C8ePHkZSU1OQ5jEYjPD09sWLFCjz55JMAzCNz33zzDdLT01udXavVQqVSQaPRwMODE3oSUesVVdRixLLd0BlM+PzpGAy/9kuJiJpPU1OHwa/tgkkADr54B7p2dhE7UqtJZmROr9cjNTUVCQkJDbYnJCTg0KFDTR6TlJTUaP9x48bh6NGjqKura/KY6upq1NXVwcur4f0nmZmZCAwMRGhoKB599FFkZ2ffwndDRNR6a/ZlQ2cwYXD3zhjWk6NyRK2hcnG0TFFyQOKjc5IpcyUlJTAajfDz82uw3c/PD2p100tyqNXqJvc3GAwoKWn6GvmLL76Irl27YsyYMZZtMTEx+PTTT/HTTz9hzZo1UKvViI+PR2np9W+a1Ol00Gq1DV5ERLeqtFKHz5PNt5bMubMXZDKZyImIpKv+vrn9mdK+b04yZa7eH39wCYJwwx9mTe3f1HYAePPNN7Fp0yZ8/fXXcHZ2tmwfP348Jk2ahP79+2PMmDH44YcfAADr16+/7nmXLl0KlUpleQUFBd38myMiuomPDuSgps6IAd1UGN3bR+w4RJI24totCgezSmAySeaus0YkU+a8vb2hUCgajcIVFRU1Gn2r5+/v3+T+Dg4O6NKl4aWJt956C2+88QZ27dqFAQMG3DCLm5sb+vfvj8zMzOvus2jRImg0GssrPz//hu9JRHQz5dV6fHooF4B5DVaOyhHdmkFBndFJ6YCr1XU4fUW6V9AkU+acnJwQFRWFxMTEBtsTExMRHx/f5DFxcXGN9t+1axeio6Ph6Oho2faf//wH//rXv7Bz505ER0ffNItOp0NGRgYCAgKuu49SqYSHh0eDFxHRrfj4YC6q9EZE+Ltb1pckotZzVMgtT4NL+alWyZQ5AFiwYAE++ugjrFu3DhkZGZg/fz7y8vIwa9YsAObRsPonUAHzk6sXL17EggULkJGRgXXr1mHt2rVYuHChZZ8333wTL7/8MtatW4eQkBCo1Wqo1WpUVlZa9lm4cCH27t2LnJwcpKSk4KGHHoJWq8VTTz3Vcd88Edm1Sp0Bn1wblZt9R0+OyhG1kZG9zZdaD0j4vjkHsQO0xOTJk1FaWorXXnsNBQUF6NevH3bs2IHg4GAAQEFBQYM550JDQ7Fjxw7Mnz8f77//PgIDA7F8+XJMmjTJss/KlSuh1+vx0EMPNTjXK6+8giVLlgAALl26hMceewwlJSXw8fFBbGwskpOTLeclImpvnydfhKamDmE+bhjf7/pXBYioZYb3NJe5oxfLUK03wNVJUtUIgMTmmZMyzjNHRK1VW2fE8GW/oqRSj7ceHoiHorqJHYnIZgiCgOHLduNyeQ0+/tNtuD1cercwSOoyKxGRPdp8OA8llXp083TBfYMCxY5DZFPMS3uZR+f2n5fmpVaWOSIiK6Y3mPDBPvMk5TNH9YCjgj+2idrab+u0SvMhCP5UICKyYtvSLqFAUwtfdyUe5uVVonYR36MLZDLgfGEl1JpaseO0GMscEZGVMhhNWLnnAgDgmZFhcHZUiJyIyDZ5ujlhQFcVAOBAlvQutbLMERFZqR9OFuBiaTU8XR0xJaa72HGIbNpvS3tJ71IryxwRkRUymQS8vzsLAPDnYaGSnC6BSEqGS3hpL5Y5IiIrtOtMIc4XVsJd6YAn40PEjkNk84Z094SrkwIllXpkqKW1tBfLHBGRlRGE30blnowPhsrF8SZHENGtcnL4bWkvqa0GwTJHRGRl9mWW4ORlDVwcFfjzsFCx4xDZDct8cyxzRER0K97/1Twq99jQ7ujSSSlyGiL7UV/mDueWobbOKHKa5mOZIyKyIinZpTicWwYnhRzPjAwTOw6RXenh0wkBKmfoDSYczikTO06zscwREVmRFdfulXsouhv8Vc4ipyGyLzKZDMN7mkfnpDTfHMscEZGVOHGpHPszS6CQyzBrZA+x4xDZpRG9zfPN7TsvnfnmWOaIiKzEyt3m1R7uGxiI7l1cRU5DZJ+G9TA/0XpWXYGiCmks7cUyR0RkBbKKKvDTGTUAYNZojsoRiaVLJyX6dfUAYJ5AWApY5oiIrMCqPdkQBCChjx96+7mLHYfIrg3vWb+0F8scERE1Q35ZNb5JvwwAePb2niKnIaKR16YoOZBZAkGw/qW9WOaIiES2Zn82jCYBw3t6Y1BQZ7HjENm9qBBPODvKUVShw/nCSrHj3BTLHBGRiIordNhyJB8A8CzvlSOyCkoHBaKDvQAAKTmlIqe5OZY5IiIRrTuYA53BhEFBnRF37Sk6IhJfTOi1Mpdt/ZMHs8wREYlEU1OHz5IuAgD+entPyGQykRMRUb2YMPM/rlJySq3+vjmWOSIikXyWlItKnQHhfu64M8JX7DhE9DsDg1RQOshRUqnHheIqsePcEMscEZEIavRGrDuYCwB49vYekMs5KkdkTZQOCgzu3hmA9d83xzJHRCSCzUfyUFalR3cvV0zoHyB2HCJqQkzotUutVn7fHMscEVEH0xtM+HBfNgBg5qgwOCj4o5jIGsWE/fZEqzXfN8efIEREHeybtMso0NTC112JSUO6iR2HiK5jSHdPOCnkKNTqcLG0Wuw418UyR0TUgYwmAav2XgAAzBgRBmdHhciJiOh6nB0VGBikAmDd982xzBERdaCdp9TIKamCysURj8V0FzsOEd1E7LUpSpKt+L45ljkiog4iCAJW7skCAEyLD0EnpYPIiYjoZn57CMJ675tjmSMi6iD7Mktw+ooWrk4KTIsPETsOETXDkODOcJDLcEVTi0tXa8SO0ySWOSKiDrJyt3lU7rGh3eHp5iRyGiJqDlcnBwzoZr5vLjnbOu+bY5kjIuoAqRevIiWnDI4KGaaPCBU7DhG1wG9Le1nnfXMsc0REHWDVtXvlHhjcFQEqF5HTEFFLxIT+Nt+cNWKZIyJqZ+fUFfg5owgyGTBzVA+x4xBRC0WHeEEhlyG/rAZXyq3vvjmWOSKidlY/Kje+nz96+HQSOQ0RtVQnpQP6BXoAsM7ROZY5IqJ2lF9Wje9OFAAAnh3dU+Q0RNRalvvmrHC+OZY5IqJ29MG+CzCaBIzo5Y1+XVVixyGiVvrtvjnrK3MtnrEyNzcX+/fvR25uLqqrq+Hj44PBgwcjLi4Ozs7O7ZGRiEiSiipq8cXRSwA4KkckddEhXpDJgJySKhRqa+HnYT2dp9llbuPGjVi+fDkOHz4MX19fdO3aFS4uLigrK8OFCxfg7OyMxx9/HC+88AKCg4PbMzMRkSSsO5ALvcGEwd07IzbMS+w4RHQLVC6O6BPggdNXtEjOLsV9g7qKHcmiWZdZhwwZgrfffhtPPPEEcnNzoVarkZqaigMHDuDMmTPQarX49ttvYTKZEB0djS+//LK9cxMRWTVNTR0+T74IwDwqJ5PJRE5ERLcq1krnm2vWyNy//vUvTJgw4bpfVyqVGD16NEaPHo1///vfyMnJabOARERS9HnyRVTqDOjt1wl3RviKHYeI2kBMqBfWHshBipWtBNGsMnejIvdH3t7e8Pb2bnUgIiKpq9Ebse6A+R+1fxndA3I5R+WIbMHQUPN9cxeKq1BcoYOPu1LsSABa8QAEABiNRmzbtg0ZGRmQyWSIiIjA/fffDweHVr0dEZFN+eJoPkqr9Ojm6YJ7BgSKHYeI2khnVyeE+7njrLoCh3PKMGFAgNiRALRiapJTp06hd+/eeOqpp7Bt2zZ8/fXXmDZtGnr16oWTJ0+2R8YGVq5cidDQUDg7OyMqKgr79++/4f579+5FVFQUnJ2dERYWhtWrVzfaZ+vWrejTpw+USiX69OmDbdu23fJ5icg+1RlN+HBfNgBg5sgwOCg4AxSRLfntvjnrudTa4p8y06dPR9++fXHp0iUcO3YMx44dQ35+PgYMGIBnnnmmPTJabNmyBfPmzcPixYuRlpaGESNGYPz48cjLy2ty/5ycHNx9990YMWIE0tLS8NJLL2HOnDnYunWrZZ+kpCRMnjwZU6dOxfHjxzF16lQ88sgjSElJafV5ich+fXf8Ci6X18C7kxMejg4SOw4RtTHLfHNWNHmwTBAEoSUHuLi44OjRo+jbt2+D7adOncJtt92Gmpr2W7MsJiYGQ4YMwapVqyzbIiMjcf/992Pp0qWN9n/hhRewfft2ZGRkWLbNmjULx48fR1JSEgBg8uTJ0Gq1+PHHHy373HXXXfD09MSmTZtadd6mXC3XwMuzMzQaDTw8PFr2jRORJJhMAsa9uw+ZRZV4/q5wzi1HZINKK3WI+vfPAIBj/xgLLzcnkRO14p658PBwFBYWNipzRUVF6Nmz/X5w6fV6pKam4sUXX2ywPSEhAYcOHWrymKSkJCQkJDTYNm7cOKxduxZ1dXVwdHREUlIS5s2bB61Wa9ln1KhRWLlyJbRaLfR6PY4ePYo5c+Y02mffvn0Ntv2eTqeDTqcDAOzLLMWr208AwHX3JyLp+yWjEOfyi9BJqcC9fTz5953IBjkCCPWQ4UJxFXafvIixffza9Xzu7u43ndqoxWXujTfewJw5c7BkyRLExsYCAJKTk/Haa69h2bJlDX54teUIVElJCYxGI/z8Gv6P5ufnB7Va3eQxarW6yf0NBgNKSkoQEBAAtVoNDw8PqFSNl9n5/bYnnniiyXM0ddyNBAXxsguRPQhaJnYCImpvD73b/udozhW9Fpe5iRMnAgAeeeQRS1Osv1J7zz33WP4sk8lgNBpb+vY39cd2Wn+uluz/x+2urq7QaDSWP2/ZsgWzZ89GcXExCgoKEBERgcTERAwdOtSyz3/+8x9s3rwZqampTZ739yNzRpOAsW/vQeb/nsQ3e47g9sG9m/ndUnvRarUICgpCfn4+L3tbAVv4PFKyS/H0+qNwcpBj17yR8LaSKQtayxY+E1vCz8O6ZF4qxtCht+Hi2RPt/nm4u7vfdJ8Wl7ndu3e3Ksyt8vb2hkKhaDQKV1RU1Gj0rZ6/v3+T+zs4OKBLly6WfQoLCxt8GJWVlfD394eHhwecnZ2hUChQUVHRYB+tVovAwMBmf4hDegQgE8C5qybcx7+IVsPDw4M/GK2IlD+PT1MzIFe64rHYYIR19RE7TpuR8mdii/h5WIde3QBT1VWr+TxaXOZGjRrVHjluysnJCVFRUUhMTMQDDzxg2Z6YmIj77ruvyWPi4uLw3XffNdi2a9cuREdHw9HR0bJPYmIi5s+f32Cf+Pj4Vp+3KUO6eWALgLRLvIeGyNacvKTB/swSKOQyPDMyTOw4RGRnmlXm8vLy0L1792a/6eXLl9G1a9svQLtgwQJMnToV0dHRiIuLw4cffoi8vDzMmjULALBo0SJcvnwZn376KQDzk6srVqzAggULMGPGDCQlJWHt2rWWp1QBYO7cuRg5ciSWLVuG++67D99++y1+/vlnHDhwoNnnbY7BQebmfvyyFkaTAAVnhCeyGav2ZgEA7h0YiCAvV5HTEJHdEZrB19dXmD59upCSknLdfcrLy4UPP/xQ6Nu3r7B8+fLmvG2rvP/++0JwcLDg5OQkDBkyRNi7d6/la0899ZQwatSoBvvv2bNHGDx4sODk5CSEhIQIq1atavSeX375pRAeHi44OjoKERERwtatW1t03ua4UqAWAAhB874QTl0ub9Gx1PZqa2uFV155RaitrRU7CgnS/jyyiiqEkBe/F4Jf+F44p9aKHafNSPkzsUX8PKyLtX0ezZpnrqysDG+88QbWrVsHR0dHREdHIzAwEM7Ozrh69SrOnDmD06dPIzo6Gi+//DLGjx/fATVUWrRaLVQqFYLmfYElk6Lx5+GhYkciojbw/FfH8cXRSxgT6YePnooWOw4R2aFmrQBx6dIlLFu2DFeuXMHq1avRu3dvlJSUIDMzEwDw+OOPIzU1FQcPHmSRawZrWgKEiFqvQFODbWmXAQDP3t5D5DREZK+adc/c4MGDoVar4ePjg7/97W84cuSI5WlQarnDOWUwmQTIed8ckaSt2ZeDOqOAmFAvDOnuKXYcIrJTzRqZ69y5M7KzzQtH5+bmwmQytWsoW+bsKMfV6jpkFlWKHYWIbkFZlR6bDpvXZ372di7bRUTiadbI3KRJkzBq1CgEBARAJpMhOjoaCoWiyX3rSx81bXCQJ1Iu1yAlpxTh/jefCJCIrNMnh3JRU2dE30APjOzlLXYcIrJjzRqZ+/DDD/HNN9/gb3/7GwRBwIwZMzB37twmX/Zs5cqVCA0NhbOzM6KiorB///5G+0QFmy/FpGSXYe/evYiKioKzszPCwsKwevXqjo5s05rzedT7+uuvMXbsWPj4+MDDwwNxcXH46aefOjCt7WvJ5/F7Bw8ehIODAwYNGtS+AVugSmfA+kO5AIBnR/e86bqJ1qqln4lOp8PixYsRHBwMpVKJHj16YN26dR2U1va19PPYsGEDBg4cCFdXVwQEBOBPf/oTSkt5T3Zb2LdvH+655x4EBgZCJpPhm2++uekxov5Ob+njr9OmTRO0Wtt5/L6tbN68WXB0dBTWrFkjnDlzRpg7d67g5uYmXLx4URAEQdBoNAIA4ZfjOULwC98Lg5b8KLi6ugpz584Vzpw5I6xZs0ZwdHQUvvrqK5G/E9tws8/jj+bOnSssW7ZMOHz4sHD+/Hlh0aJFgqOjo3Ds2LEOTm6bWvp51CsvLxfCwsKEhIQEYeDAgR0TthnW7LsgBL/wvXD7f3YLBqNJ7Dit0prP5N577xViYmKExMREIScnR0hJSREOHjzYgaltV0s/j/379wtyuVz43//+J2RnZwv79+8X+vbtK9x///0dnNw27dixQ1i8eLGwdetWAYCwbdu2G+6fnZ0t6u/0Fpc5atrQoUOFWbNmNdgWEREhvPjii4Ig/FbmikrLhN6LdwjBL3wv9I4e0WD/mTNnCrGxsR2W2Zbd7PNojj59+givvvpqW0ezS639PCZPniy8/PLLwiuvvGI1Za62ziAMfT1RCH7he2Hz4RuXUWvW0s/kxx9/FFQqlVBaWtoR8exOSz+P//znP0JYWFiDbcuXLxe6devWbhntVXPK3PPPPy9EREQ02NaRv9ObdZmVbkyv1yM1NRUJCQkNtickJODQoUMNtikdFBjcvTMAIGLEPQ2+Nm7cOBw9ehR1dXXtmtfWteTzuB6TyYSKigp4eXm1R0S70trP4+OPP8aFCxfwyiuvtHfEFtl27DIKtTr4eShx/+C2X+mmI7TmM9m+fTuio6Px5ptvomvXrujduzcWLlyImpqajohs01rzecTHx+PSpUvYsWMHBEFAYWEhvvrqK0yYMKEjItMfJCUlNfr8OvJ3OstcGygpKYHRaISfn1+D7X5+flCr1Y32jwk1T+tS6RrQaH+DwYCSkpL2C2sHWvp5NOW///0vqqqq8Mgjj7RHRLvSms8jMzMTL774IjZs2AAHhxYvId1ujCYBq/deAADMGBEGpUPTD4JZu9Z8JtnZ2Thw4ABOnTqFbdu24d1338VXX32Fv/71rx0R2aa15vOIj4/Hhg0bMHnyZDg5OcHf3x+dO3fGe++91xGR6Q/UanWTn19H/U5nmWtDf7wJWhCEJm+Mjgkzj/YUGDtB+N0CHPX/LdWbqa1Ncz+PP9q0aROWLFmCLVu2wNfXt73i2Z3mfh5GoxFTpkzBq6++it69e3dUvGbZcbIAuaXV6OzqiMeGNn+9amvVkr8jJpMJMpkMGzZswNChQ3H33Xfj7bffxieffMLRuTbSks/jzJkzmDNnDv75z38iNTUVO3fuRE5OTovWDKe21dTn19T29mA9/+SVMG9vbygUikb/gioqKmrU1AGYJxc1GVAtd8TF0mqEeLtZ9ndwcOCEzLeopZ/H723ZsgVPP/00vvzyS4wZM6Y9Y9qNln4eFRUVOHr0KNLS0jB79mwA5iIhCAIcHBywa9cu3HHHHR2S/fcEQcDKPeZRuWnxIXBTSvfHZ2v+jgQEBKBr165QqVSWbZGRkRAEAZcuXUKvXr3aNbMta83nsXTpUgwbNgx///vfAQADBgyAm5sbRowYgX//+98ICAho8jhqH/7+/k1+fh31O50jc23AyckJUVFRSExMbLA9MTER8fHxjfZ3dlTAW1YFoOHSXrt27UJ0dDQcHR3bN7CNa+nnUW/Tpk2YNm0aNm7cyPtO2lBLPw8PDw+cPHkS6enpltesWbMQHh6O9PR0xMTEdFT0BvacK0ZGgRauTgpMiw8RJUNbac3fkWHDhuHKlSuorPxtwvPz589DLpejW7du7ZrX1rXm86iuroZc3vBXeP38r8LNl1ynNhYXF9fo8+vQ3+kd8piFHah/rHzt2rXCmTNnhHnz5glubm5Cbm6uIAiCMH/+fAGAoNFoBEEQhMWbk4XgF74XRiw0P4a+du1aTk3Shm72ebz44ovC1KlTLftv3LhRcHBwEN5//32hoKDA8iovLxfrW7ApLf08/sganmZ9aNVBIfiF74XXfzgjao620tLPpKKiQujWrZvw0EMPCadPnxb27t0r9OrVS5g+fbpY34JNaenn8fHHHwsODg7CypUrhQsXLggHDhwQoqOjhaFDh4r1LdiUiooKIS0tTUhLSxMACG+//baQlpZmmSrmj59H/dQk8+fPF+V3OstcG3r//feF4OBgwcnJSRgyZIiwd+9ey9cee+yxBmVu3/kiIfiF74XQOZ8LTk5OQkhIiLBq1SqxotukG30eTz31lDBq1CjLn0eNGiUAaPR66qmnOj64jWrJ5/FHYpe5lOxSIfiF74VeL+0Q1Joa0XK0tZZ+JhkZGcKYMWMEFxcXoVu3bsKCBQuE6urqDk5tu1r6eSxfvlzo06eP4OLiIgQEBAiPP/64cOnSpQ5ObZt27959w98JTX0ee/bsEQYPHizK73SZIHA8tiNotVqoVCpoNBp4eHigWm/AgCW7YDAJ2P/87QjychU7IhFdx7SPD2PPuWJMiemONx7oL3YcIqIGeM+cSFydHNC/m/lG4pScMpHTENH1nLqswZ5zxZDLgJkjw8SOQ0TUCMuciOrnm0vJ5lp6RNZq1bV55e4ZGIjgLm4ipyEiaoxlTkT1881xZI7IOmUXV2LHyQIAwF9G9xA5DRFR01jmRBQd7Am5DMgrq0aBhpNuElmbD/ZmQxCAMZG+iPD3EDsOEVGTWOZE5O7siH5dr903l83ROSJrcqW8Bl+nXQIA/GV0T5HTEBFdH8ucyGJC6y+18r45ImuyZn826owCYsO8EBXsKXYcIqLrYpkTWf1DEIcusMwRWYvSSh02H84HADzLUTkisnIscyKLCfOCQi7DxdJq5JdVix2HiAB8cigXNXVG9O+qwohe3mLHISK6IZY5kbk7O2JwUGcAwIGsEnHDEBEqauuw/lAuAOCvt/eATCYTNxAR0U2wzFmBYT3N//JnmSMS34aUPGhrDejh44aEPv5ixyEiuimWOStQfxnnUFYJTCaurkYklto6Iz7anwPA/ASrXN68UbnRo0dj9uzZmD17Njp37owuXbrg5ZdfBldLJKKOwDJnBQYGdUYnpQOuVtfh9BWt2HGI7NaWI/koqdShm6cL7hsU2KJj169fDwcHB6SkpGD58uV455138NFHH7VTUiKi37DMWQFHhRyx11aD2J9VLHIaIvukN5jwwbWlu2aO6gFHRct+PAYFBeGdd95BeHg4Hn/8cTz33HN455132iMqEVEDLHNWYvi1++YO8r45IlF8k3YZVzS18HVX4uGobi0+PjY2tsHDEnFxccjMzITRaGzLmEREjbDMWYnhvXwAAEdyr6K2jj/8iTqS0SRg1bVRuRkjwuDsqBA5ERFR87HMWYkePm7w93CG3mDC4Rwu7UXUkX44WYCckip0dnXElJjurXqP5OTkRn/u1asXFAoWQyJqXyxzVkImk2F4L15qJepoJpOAlbuzAAB/ig+Fm9KhVe+Tn5+PBQsW4Ny5c9i0aRPee+89zJ07ty2jEhE1qXU/tahdjOjlja9SL2F/ZgkWiR2GyE78crYIZ9UV6KR0wLT4kFa/z5NPPomamhoMHToUCoUCzz33HJ555pm2C0pEdB0sc1Ykvod5ZO5MgRYllTp4d1KKnIjItgmCgBXXRuWeiA2GytWx1e/l6OiId999F6tWrWqreEREzcLLrFbEx12JCH93AMChC6UipyGyfQezSnE8vxxKBzmeHh4qdhwiolZhmbMy9VOUHMjkfHNE7W3F7kwAwGNDu8PHnSPhRCRNvMxqZYb38sZHB3JwILMEgiBwkW+idpJ6sQzJ2WVwVMjwzMiwW3qvPXv2tE0oIqJW4MiclRka6gUnhRxXNLXIKakSOw6RzVrxq/leuQcHd0NgZxeR0xARtR7LnJVxdXLAkODOAIADnKKEqF2cuqzB7nPFkMuAv4zuIXYcIqJbwjJnhUZcWw1ifybLHFF7WLnHPCo3cUAgQrzdRE5DRHRrWOasUP1DEMkXSmEwmkROQ2Rbsooq8OMpNQDgr7f3FDkNEdGtY5mzQv26qqBycUSFzoDjlzRixyGyKSv3XIAgAGP7+CH82lRARERSJpkyd/XqVUydOhUqlQoqlQpTp05FeXn5DY8RBAFLlixBYGAgXFxcMHr0aJw+fdry9bKyMjz33HMIDw+Hq6srunfvjjlz5kCjaVigQkJCIJPJGrxefPHF9vg2AQAKuQzxPboAAA7wUitRm8krrca36VcAcFSOiGyHZMrclClTkJ6ejp07d2Lnzp1IT0/H1KlTb3jMm2++ibfffhsrVqzAkSNH4O/vj7Fjx6KiogIAcOXKFVy5cgVvvfUWTp48iU8++QQ7d+7E008/3ei9XnvtNRQUFFheL7/8crt8n/W4TitR21u5JwtGk4BRvX0wKKiz2HGIiNqEJOaZy8jIwM6dO5GcnIyYmBgAwJo1axAXF4dz584hPDy80TGCIODdd9/F4sWL8eCDDwIA1q9fDz8/P2zcuBEzZ85Ev379sHXrVssxPXr0wOuvv44nnngCBoMBDg6//c/j7u4Of3//dv5Of1N/39yxvKuo1BnQqZWLfxOR2aWr1fgq9RIAYM6dHJUjItshiZG5pKQkqFQqS5EDgNjYWKhUKhw6dKjJY3JycqBWq5GQkGDZplQqMWrUqOseAwAajQYeHh4NihwALFu2DF26dMGgQYPw+uuvQ6/X3zCzTqeDVqtt8GqJ4C5uCPJygcEkICWbS3sR3apVey7AYBIwrGcXRAV7iR2HiKjNSKLMqdVq+Pr6Ntru6+sLtVp93WMAwM/Pr8F2Pz+/6x5TWlqKf/3rX5g5c2aD7XPnzsXmzZuxe/duzJ49G++++y6effbZG2ZeunSp5f4+lUqFoKCgG+7flPopSvac49JeRLeiQFODL49eG5W7o5fIaYiI2paoZW7JkiWNHiz44+vo0aMA0OSyVs1Z7uqPX7/eMVqtFhMmTECfPn3wyiuvNPja/PnzMWrUKAwYMADTp0/H6tWrsXbtWpSWXn/EbNGiRdBoNJZXfn7+DXM25Y5wc4H99WwRBEFo8fFEZPbB3mzojSbEhHohJqyL2HGIiNqUqDdizZ49G48++ugN9wkJCcGJEydQWFjY6GvFxcWNRt7q1d/fplarERAQYNleVFTU6JiKigrcdddd6NSpE7Zt2wZHR8cbZoqNjQUAZGVloUuXpn8xKJVKKJW3tnD3sJ7eUDrIcbm8BucKKxDh73FL70dkj4q0tdh4OA8AMOdOjsoRke0Rtcx5e3vD29v7pvvFxcVBo9Hg8OHDGDp0KAAgJSUFGo0G8fHxTR4TGhoKf39/JCYmYvDgwQAAvV6PvXv3YtmyZZb9tFotxo0bB6VSie3bt8PZ2fmmedLS0gCgQUlsDy5OCgzr6Y1fzxbhl4wiljmiVvhgXzb0BhOigj0tU/4QEdkSSdwzFxkZibvuugszZsxAcnIykpOTMWPGDEycOLHBk6wRERHYtm0bAPPl1Xnz5uGNN97Atm3bcOrUKUybNg2urq6YMmUKAPOIXEJCAqqqqrB27VpotVqo1Wqo1WoYjUYA5ocv3nnnHaSnpyMnJwdffPEFZs6ciXvvvRfdu3dv9+/9jgjzpdZfMhqPTBLRjZVU6rAh5SIA86jczW7LICKSIsnMd7FhwwbMmTPH8nTqvffeixUrVjTY59y5cw0m/H3++edRU1ODZ599FlevXkVMTAx27doFd3fzrO+pqalISUkBAPTs2XCqgpycHISEhECpVGLLli149dVXodPpEBwcjBkzZuD5559vz2/X4s5IX7z8DZCWX47SSh26dLq1S7dE9mTN/mzU1pkwMKgzRva6+VUAIiIpkgm8s75DaLVaqFQqy9QnLXH3//bjTIEWbz08EA9FdWunhES2paxKj+HLfkW13oi1T0Xjzsim768lIpI6SVxmtXdjIuufauWlVqLmWnsgG9V6I/oGelhuVyAiskUscxJwx7URhX3nS6A3mEROQ2T9yqv1WH+I98oRkX1gmZOAAV1V8O6kRKXOgMM5ZWLHIbJ6Hx/MRaXOgAh/d4zl5VUisnEscxIgl8twR4R5NYhfeKmV6Ia0tXVYdzAHgHlUTi7nqBwR2TaWOYm4I8I8uvBLBleDILqR9QdzUVFrQC/fTrirr7/YcYiI2h3LnESM6OUNJ4UceWXVuFBcKXYcIqtUqTNg7bVRudl39OSoHBHZBZY5iXBTOiD22uz1v2QUiZyGyDp9lnQR5dV1CPN2w8QBgWLHISLqECxzEnKnZTUIljmiP6rWG7BmfzYA86icgqNyRGQnWOYkpH6urKMXy1BerRc5DZF12ZCch7IqPYK7uOLegRyVIyL7wTInIUFergj3c4dJAPaeLxY7DpHVqNEb8cE+86jcX0f3hIOCP9qIyH7wJ57E3HltNYifeamVyGJDykWUVOrQtbMLHhjSVew4REQdimVOYurL3N5zRagzcjUIomq9Aav3XgAAPHdHTzhyVI6I7Ax/6knMoCBPeLk5QVtrQOrFq2LHIRLdp0kXUVKpR3cvV0yK6iZ2HCKiDscyJzEKuQyjw6+tBpHB1SDIvlXqDPjg2qjcnDt7cVSOiOwSf/JJ0J31q0Gc5X1zZN8+OZiDq9fmlbt/EJ9gJSL7xDInQSN7e8NBLkN2cRVySqrEjkMkCm1tHT689gTr3DG9+AQrEdkt/vSTIHdnR8SEeQHgpVayX2v350B7bQ1WrvZARPaMZU6i7rh2qfVXXmolO1Rerce6A+Y1WOeN6c3VHojIrrHMSdSYa1OUHM4pg7a2TuQ0RB1rzf5sVOgMiPB3x/h+/mLHISISFcucRAV3cUMPHzcYTAL2cTUIsiNlVXp8fDAXADB/bG/IOSpHRHaOZU7CxkReu9TK1SDIjnyw9wKq9Ub06+qBhD5+YschIhIdy5yE3RFhvtS6+1wRjCZB5DRE7a+4Qof1SbkAgAVje0Mm46gcERHLnIRFBXtC5eKIq9V1SMvjahBk+1btuYDaOhMGBXXG7eG+YschIrIKLHMS5qCQW1aDSDzDKUrIthVqa/F5ykUAHJUjIvo9ljmJG9fX/CTfDycLIAi81Eq26/3dWdAbTIgO9sSIXt5ixyEishoscxJ3e7gvXJ0UuHS1BicuacSOQ9QuLpfXYPPhfADAggSOyhER/R7LnMS5OClw57WnWn84WSByGqL2seLXLOiNJsSGeSG+B0fliIh+j2XOBkzoHwAA+OEEL7WS7ckvq8aXR6+Nyo0NFzkNEZH1YZmzAaPDfeDmpMDl8hqk5ZeLHYeoTS3/JRMGk4ARvbwxNNRL7DhERFaHZc4GODsqMPba5Kk/nOClVrIdOSVV+DrtMgDzag9ERNQYy5yNmDAgEIC5zJk4gTDZiOW/ZMJoEnB7uA+GdPcUOw4RkVVimbMRI3t7w13pALW2Fsc4gTDZgKyiCnybbh6V471yRETXxzJnI5QOCozta77U+j0vtZINeOun8zAJwNg+fujfTSV2HCIiq8UyZ0MmDjA/1brjJC+1krSl55dj52k15DLg7+M4KkdEdCMsczZkeE8fuDs7oKhChyO5ZWLHIWoVQRCw7MezAIAHh3RDbz93kRMREVk3ljkb4uQgb7C8F5EU7cssQVJ2KZwUcswb00vsOEREVo9lzsb8dqlVDSMvtZLEmEwC3txpHpWbGheMbp6uIiciIrJ+LHM2ZlhPb6hcHFFSqUNKTqnYcYha5PuTBTh9RQt3pQP+entPseMQEUkCy5yNcVTIcVf9pVY+1UoSojeY8N9d5wAAz4wMg5ebk8iJiIikgWXOBk0caL7UuvOUGgajSeQ0RM2z5Wg+LpZWw7uTEn8eHip2HCIiyWCZs0FxYV3g6eqI0io9krP5VCtZv2q9Act/yQQAzLmzJ9yUDiInIiKSDpY5G+SgkOOufubRuR9OXhE5DdHNrTuQg+IKHbp7ueLR27qLHYeISFIkU+auXr2KqVOnQqVSQaVSYerUqSgvL7/hMYIgYMmSJQgMDISLiwtGjx6N06dPN9hn9OjRkMlkDV6PPvroLZ9bbPcM+O1Sax0vtZIVu1qlxwd7swEAf0voDScHyfxYIiKyCpL5qTllyhSkp6dj586d2LlzJ9LT0zF16tQbHvPmm2/i7bffxooVK3DkyBH4+/tj7NixqKioaLDfjBkzUFBQYHl98MEHt3xusQ0N9YJ3Jydcra5D0gU+1UrWa+WeLFToDOgT4IF7BgSKHYeISHIkcWNKRkYGdu7cieTkZMTExAAA1qxZg7i4OJw7dw7h4Y2X+xEEAe+++y4WL16MBx98EACwfv16+Pn5YePGjZg5c6ZlX1dXV/j7+7fZua2B+VKrPz5PzsP3J65gZG8fsSMRNXKlvAbrky4CAJ6/KxxyuUzkRERE0iOJkbmkpCSoVCpLmQKA2NhYqFQqHDp0qMljcnJyoFarkZCQYNmmVCoxatSoRsds2LAB3t7e6Nu3LxYuXNhg5K415wYAnU4HrVbb4NXRJvQ3j3L8dLoQegMvtZL1effn89AbTIgN88Io/oODiKhVJFHm1Go1fH19G2339fWFWq2+7jEA4Ofn12C7n59fg2Mef/xxbNq0CXv27ME//vEPbN261TKS19pzA8DSpUst99ipVCoEBQXd+JtsB0NDveDnoYSmpg6/ni3s8PMT3UhmYQW+Sr0EAHj+rgjIZByVIyJqDVHL3JIlSxo9fPDH19GjRwGgyR/0giDc9BfAH7/+x2NmzJiBMWPGoF+/fnj00Ufx1Vdf4eeff8axY8eu+x7NOfeiRYug0Wgsr/z8/BvmbA8KuQwPDO4GAJZfmkTW4q1d52ASgHF9/TCku6fYcYiIJEvUe+Zmz57d6MnRPwoJCcGJEydQWNh4ZKm4uLjRyFu9+nvg1Go1AgICLNuLioquewwADBkyBI6OjsjMzMSQIUPg7+/f4nMD5ku6SqXyul/vKA9FdcPqvRew+1wxiipq4evuLHYkIqReLMNPpwshlwF/H2ed950SEUmFqCNz3t7eiIiIuOHL2dkZcXFx0Gg0OHz4sOXYlJQUaDQaxMfHN/neoaGh8Pf3R2JiomWbXq/H3r17r3sMAJw+fRp1dXWWAtiac1uTnr6dMLh7ZxhNAr5Juyx2HCKYTAJe+z4DAPBIdBB6+rqLnIiISNokcc9cZGQk7rrrLsyYMQPJyclITk7GjBkzMHHixAZPk0ZERGDbtm0AzJdG582bhzfeeAPbtm3DqVOnMG3aNLi6umLKlCkAgAsXLuC1117D0aNHkZubix07duDhhx/G4MGDMWzYsBad25o9HGW+X++r1EsQBEHkNGTvvjtxBcfzy+HmpMCChN5ixyEikjxJlDnA/MRp//79kZCQgISEBAwYMACfffZZg33OnTsHjUZj+fPzzz+PefPm4dlnn0V0dDQuX76MXbt2wd3dPBLg5OSEX375BePGjUN4eDjmzJmDhIQE/Pzzz1AoFC06tzWbODAASgc5zhdW4sQlzc0PIGontXVGvLnzHADg2dt78rI/EVEbkAkcqukQWq0WKpUKGo0GHh4eHX7+uZvT8G36FTwR2x3/vr9/h5+fCADe352F//x0DoEqZ/y6cDScHRU3P4iIiG5IMiNzdGvqL7VuT7+C2jqjyGnIHhVX6LBydxYA4IXxESxyRERthGXOTsT16IJAlTO0tQYknuGcc9Tx3k48jyq9EQODOnPZLiKiNsQyZycUchkmRZnnnPuSc85RBzur1mLLkTwAwD8mRHLZLiKiNsQyZ0ceulbmDmQWQ62pFTkN2QtBEPD6DxkwCcCE/gGIDvESOxIRkU1hmbMjwV3cMDTECyYB2HqMo3PUMfacL8b+zBI4KeR44a4IseMQEdkcljk781D0b8t78UFmam8Gowmv/2CeIPhPw0LQvYuryImIiGwPy5ydmdA/AK5OCuSUVOFY3lWx45CN23Q4D1lFlfByc8Kzt/cUOw4RkU1imbMzbkoHjO9nXqrsy6O81ErtR1NTh3d+zgQAzB/TCyoXR5ETERHZJpY5O/TwtUut358oQLXeIHIaslUrd2ehrEqPnr6d8NjQ7mLHISKyWSxzdmhoiBe6e7miUmfAT6fVYschG5RXWo2PD+YCABbfHQkHBX/UEBG1F/6EtUNyuQyThphH5744wkut1PaW7TwLvdGEEb28MTrcR+w4REQ2jWXOTj0U3Q1yGZCUXYrMwgqx45ANOXShBD+cLIBcBrx0dyRkMk4QTETUnljm7FTXzi4Y28cPALA+KVfcMGQz6owm/PPb0wCAJ2KDERngIXIiIiLbxzJnx56KDwEAfH3sMrS1deKGIZvw8cEcZBVVooubE/42NlzsOEREdoFlzo7FhXVBuJ87qvVGTlNCt6xAU4N3r01F8uL4CKhcORUJEVFHYJmzYzKZDE/GBwMAPkvKhcnEFSGo9V7/IQPVeiOigj0tD9gQEVH7Y5mzcw8M7goPZwfkllZj7/liseOQRB3MKsH3J8wPPbx2X1/I5XzogYioo7DM2TlXJwc8Eh0EAPjkUK64YUiS9AYT/vntKQDAk3Eh6BuoEjkREZF9YZkjPBkXApkM2Hu+GNnFlWLHIYlZdzAHF4qr4N3JCfPH9hY7DhGR3WGZI3Tv4oo7wn0BAJ8mXRQ5DUnJlfIaLP/F/NDDovGRXH+ViEgELHME4LdpSr5KvYRKHddrpeapf+jhthBPPDikq9hxiIjsEsscAQCG9/RGmI8bKnUGfH2M05TQze3PLMYPJwugkMvw2n39uNIDEZFIWOYIgHm91qfiQgAA6w/lQhA4TQldn85gxCvXVnp4Mo4rPRARiYlljiwmRXVDJ6UDLhRX4UBWidhxyIqtPZCD7JIqeHdS8qEHIiKRscyRRSelAx6KMk/2up7TlNB1XC6vwXu/ZAEAFk+IgIczH3ogIhITyxw18GSceUWIX84WIa+0WuQ0ZI3+/f0Z1NQZMTTEC/cP4kMPRERiY5mjBsJ8OmFkbx8IAvBZcq7YccjK7D5bhB9Pqc0PPdzflw89EBFZAZY5amTatfVaNx/Jh7a2TuQ0ZC20tXVY9PVJAMCfh4Ugwp8PPRARWQOWOWpkdG9f9PLthIpaAz7lvXN0zdIdGVBraxHSxRULxoaLHYeIiK5hmaNG5HIZZt/RE4D5qcUqTiJs9w5klmDT4XwAwLJJA+DipBA5ERER1WOZoyZNHBCIUG83XK2uw4YULvFlz6p0Bryw9QQA4Km4YMSEdRE5ERER/R7LHDVJIZfhL6N7AAA+3JeD2jqjyIlILMt2nsXl8hp07eyC5++KEDsOERH9AcscXdcDg7uim6cLSip12HQ4T+w4JIKU7FJ8mmQemV02aQDclA4iJyIioj9imaPrclTILaNzH+zNhs7A0Tl7UqM3Wi6vPjY0CMN7eYuciIiImsIyRzf0UFQ3+Hs4Q62txVepl8SOQx3ov7vOIbe0GgEqZyy6O1LsOEREdB0sc3RDSgcFZo4KAwCs2nMBdUaTyImoIxzLu4q1B3MAAG880J9LdhERWTGWObqpR2/rDu9OTrh0tQbfpF0WOw61s9o6I/7+5XEIAvDgkK64PcJX7EhERHQDLHN0Uy5OCswYYR6dW7nnAowmQeRE1J6W/5KJC8VV8HFX4p8T+4gdh4iIboJljprl8dhgdHZ1RE5JFb4/cUXsONROTl7S4IN92QCAf9/fD51dnUROREREN8MyR83SSemAp4eFAgBW/JoFE0fnbI7eYMLfvzoOo0nAxAEBGNfXX+xIRETUDCxz1GxPDQuBu7MDMosq8dNptdhxqI29vzsLZ9UV8HJzwqv39hU7DhERNRPLHDWbh7MjpsWHAACWc3TOpmQUaPH+7iwAwKv39kWXTkqRExERUXNJpsxdvXoVU6dOhUqlgkqlwtSpU1FeXn7DYwRBwJIlSxAYGAgXFxeMHj0ap0+ftnw9NzcXMpmsydeXX35p2S8kJKTR11988cX2+lat2p+HhcJd6YCMAi2+OsZ552xBjd6IOZvSYDAJSOjjh4kDAsSORERELSCZMjdlyhSkp6dj586d2LlzJ9LT0zF16tQbHvPmm2/i7bffxooVK3DkyBH4+/tj7NixqKioAAAEBQWhoKCgwevVV1+Fm5sbxo8f3+C9XnvttQb7vfzyy+32vVozTzcnPHdnTwDAf346h0qdQeREdKte/e40Mosq4euuxBsP9odMJhM7EhERtYAkFlrMyMjAzp07kZycjJiYGADAmjVrEBcXh3PnziE8PLzRMYIg4N1338XixYvx4IMPAgDWr18PPz8/bNy4ETNnzoRCoYC/f8ObvLdt24bJkyejU6dODba7u7s32tdeTYsPxcaUPOSWVuP93Vl4gYuvS9b241ew+Ug+ZDLg3cmD4M3Lq0REkiOJkbmkpCSoVCpLkQOA2NhYqFQqHDp0qMljcnJyoFarkZCQYNmmVCoxatSo6x6TmpqK9PR0PP30042+tmzZMnTp0gWDBg3C66+/Dr1ef4vflXQ5Ocjx0rXlndbuz0F+WbXIiag1LpZW4aWvTwIAZt/eE/E9ufYqEZEUSWJkTq1Ww9e38Sz0vr6+UKubfqqyfrufn1+D7X5+frh48WKTx6xduxaRkZGIj49vsH3u3LkYMmQIPD09cfjwYSxatAg5OTn46KOPrptZp9NBp9NZ/qzVaq+7rxSN7eOHYT274GBWKd7YkYFVT0SJHYlaQG8w4blNaajUGXBbiCfm3tlL7EhERNRKoo7MLVmy5LoPINS/jh49CgBN3scjCMJN7+/549evd0xNTQ02btzY5Kjc/PnzMWrUKAwYMADTp0/H6tWrsXbtWpSWll73vEuXLrU8rKFSqRAUFHTDnFIjk8nwj4l9IJcBP55SIzn7+v9bkPV5c+dZnLikgcrFEf97dDAcFJIYpCcioiaI+hN89uzZyMjIuOGrX79+8Pf3R2FhYaPji4uLG4281au/v+2PI3dFRUVNHvPVV1+huroaTz755E1zx8bGAgCysrKuu8+iRYug0Wgsr/z8/Ju+r9RE+HtgSkx3AMCr353hMl8S8evZQnx0IAcA8NbDAxHY2UXkREREdCtEvczq7e0Nb++b36cTFxcHjUaDw4cPY+jQoQCAlJQUaDSaRpdE64WGhsLf3x+JiYkYPHgwAECv12Pv3r1YtmxZo/3Xrl2Le++9Fz4+PjfNk5aWBgAICLj+FA5KpRJKpe3fTL5gbDi2p19BRoEWXx7Nx6NDu4sdiW5AranFwi9PAACmxYdgbJ+m/zFERETSIYlrK5GRkbjrrrswY8YMJCcnIzk5GTNmzMDEiRMbPMkaERGBbdu2ATBfBpw3bx7eeOMNbNu2DadOncK0adPg6uqKKVOmNHj/rKws7Nu3D9OnT2907qSkJLzzzjtIT09HTk4OvvjiC8ycORP33nsvundncfFyc8LcMb0BAG/tOoeK2jqRE9H1GE0C5m1JQ1mVHn0DPbDobj6FTERkCyRR5gBgw4YN6N+/PxISEpCQkIABAwbgs88+a7DPuXPnoNFoLH9+/vnnMW/ePDz77LOIjo7G5cuXsWvXLri7uzc4bt26dejatWuDJ1/rKZVKbNmyBaNHj0afPn3wz3/+EzNmzMCmTZva5xuVoKmxwQjzdkNJpR4rfr3+pWcS14pfs5CcXQY3JwVWTBkCpYNC7EhERNQGZIIg8EanDqDVaqFSqaDRaODh4SF2nDb369lC/PmTo3BUyJA4fxRCvN3EjkS/k5JdisfWJMMkAO9MHogHBncTOxIREbURyYzMkXW7PdwXI3v7oM4o4I0dGWLHod8pq9Jj7uZ0mARg0pBuLHJERDaGZY7ahEwmwz8mREIhl2HXmUIcyioROxLBfJ/c/C3pUGtrEebjhtfu6yt2JCIiamMsc9Rmevm5Y2psMADgte/PwGA0iZyIXv8hA3vPF8PZUY4Vjw2Bm1IS84QTEVELsMxRm5p7Zy+oXBxxVl1hmcuMxLExJQ/rDpo/g7cfGYQ+gbZ3ryYREbHMURvzdHPC4mvrtv531zmcuWJby5hJxaELJfjnt6cAAH8b2xt397/+nIhERCRtLHPU5h6O7oaEPn6oM5rv16qtM4odya7klFThL58fg8Ek4L5BgZh9R0+xIxERUTtimaM2J5PJsPTB/vDu5IRzhRX4765zYkeyG5rqOjz9yRFoauowuHtnLJs04KbrFxMRkbSxzFG76NJJiWWTBgAAPjqQg0MX+HRre6szmvDsxlRkl1QhUOWMD6dGw9mREwMTEdk6ljlqN3dG+uGxod0hCMDCL45DU8OlvtqLIAh49bvTOJhVClcnBdZOuw0+7ra/NjAREbHMUTt7eUIkQrq44oqmFku2nxY7js36NOkiPk/Og0wG/O/RwYgM4JOrRET2gmWO2pWb0gFvTx4EuQzYlnYZ35+4InYkm7P3fDFe/c5clF+8KwJj+/iJnIiIiDoSyxy1uyHdPTH7dvMTlYu3nYJaUytyIttxvrACszccg0kAHo7qhmdGhokdiYiIOhjLHHWI5+7shQHdVNDU1OHvXx2HySSIHUnyLhRXYsqaFFToDBga4oXXH+jPJ1eJiOwQyxx1CEeFHO9MHgRnRzn2Z5bg06RcsSNJWm5JFaasSUZJpQ6RAR748MkoODnwrzMRkT3iT3/qMD18OuGla6tDvL4jA8nZpSInkqb8smpMWZOMQq0Ovf064fOnh6Kzq5PYsYiISCQsc9ShpsYGY0L/ANQZBcz8LBXZxZViR5KUy+U1eGxNMq5oatHDxw0bpseiSydOQUJEZM9Y5qhDyWQy/PeRgRgU1Bmamjo8vf4orlbpxY4lCWpNLaasScalqzUI9XbDphmxnEuOiIhY5qjjOTsqsObJaHTt7IKckirM/DwVOgPXb72RIq25yF0srUZ3L1dsnBEDXw9nsWMREZEVYJkjUfi4K/Hxn26Du9IBh3PKsOjrkxAEPuHalJJKHaZ8lILskip07eyCjTNiEKByETsWERFZCZY5Ek1vP3eseHwIFHIZvj52Ge/vzhI7ktUpq9LjiY9SkFVUiQCVMzbNiEU3T1exYxERkRVhmSNRjertg1fv7QsAeGvXeXx3nCtE1MsqqsSDKw/irLoCvu5KbJwRi+5dWOSIiKghljkS3ROxwZg+PBQA8Lcvj+PQhRKRE4lv97kiPPD+QeSWVl+7tBqLUG83sWMREZEVYpkjq7Do7kiM7eMHvcGEP318BLvPFokdSRSCIOCj/dl4+pMjqNAZcFuIJ76dPQw9fTuJHY2IiKwUyxxZBYVchvceG4wxkb7QGUx45rOj+PFkgdixOpTOYMTfvzqBf/+QAZMATI4OwobpsfDmPHJERHQDLHNkNZwdFVj1RBQmDjBPKvzXjcewNfWS2LE6RHGFDlPWpOCr1EuQy4BX7umD/5vUn0t0ERHRTTmIHYDo9xwVcvzv0cFwcVTgy9RL+NuXx1FTZ8QTscFiR2s3py5r8MynR3FFUwsPZwesmDIEI3v7iB2LiIgkgmWOrI5CLsOySQPgpnTAJ4dy8fI3p1ClM+CZkWGQyWRix2tTP54swIIvzIU1zNsNHz0VjTAf3h9HRETNJxM4U2uH0Gq1UKlU0Gg08PDwEDuOJAiCgDd/OodVey4AACYMCMDSB/vDw9lR5GS3zmQSsPzXTLz7cyYAYGRvH7z32GCoXKT/vRERUcdimesgLHOtt/ZADpbuyIDBJKC7lyvee2wwBgZ1FjtWq50vrMA/vjmFlJwyAMD04aF4cXwEHBS8P46IiFqOZa6DsMzdmrS8q3huUxouXa2Bo0KGF+6KwNPDQyV12bVKZ8DyXzOxdn8ODCYBzo5yvHZfPzwSHSR2NCIikjCWuQ7CMnfrNDV1eHHrCfx4Sg0AuCPCF289PBBebk4iJ7sxQRDw02k1XvvuDK5oagEAY/v44Z8T+yDIiys6EBHRrWGZ6yAsc21DEAR8npKHf31/BnqDCf4ezlj20ACM7OVtlaN0F0ur8Mr209hzrhgA0M3TBa/e2xd3RvqJnIyIiGwFy1wHYZlrW2euaDF70zFkF1cBAKKCPTHnzl5WU+pq64z4YG823t+TBb3BBEeFDLNG9cCzo3vCxUkhdjwiIrIhLHMdhGWu7VXpDHhr1zlsSMmD3mACAAzspsKcO3vhjghfUUrdpavV2HQ4D1uO5KOkUg8AGN7TG6/e1xc9OOUIERG1A5a5DsIy136KtLX4cF82Pk+5iNo6c6nrG+iB5+7oiYQ+/pDL27fUmUwC9mUW4/Pki/j1bBFM1/5GBaic8dLdkZg4IMAqRguJiMg2scx1EJa59ldSqcOa/dn4LOkiqvVGAEC4nzv+PDwE8T280c3TpU1LlVpTi2/TL2NDSh7yyqot2+N7dMHU2GCM6eMHR043QkRE7YxlroOwzHWcsio91h3IwfpDuajQGSzbA1TOGBrqhaGhXogJ9UIPn07NLndFFbU4dVmDE5c0lv9bVKGzfN3d2QEPRXXD4zHB6OnLy6lERNRxWOY6CMtcx9PU1OHz5Iv4JaMQJy5pYDA1/H91LzcnDOnuCZWLIxwVMjgoZHCQy6/9txwyAJlFlTh5SQO1trbR+8tlQP9unTFlaBDuGRgIVyeujkdERB2PZa6DsMyJq0ZvRFreVaTklOFwThnS8q9a7q9rDpkM6OnTCf27qtC/mwoDuqkQGeDBAkdERKJjmesgLHPWRW8w4eRl8yXT2joj6owm1BkFGEwmGIwC9EYTjCYBwV3c0L+rCn0DPeCmZHEjIiLrwzLXQVjmiIiIqD3wUTsiIiIiCZNMmbt69SqmTp0KlUoFlUqFqVOnory8/IbHfP311xg3bhy8vc2rAqSnpzfaR6fT4bnnnoO3tzfc3Nxw77334tKlS7d8biIiIqKOIJkyN2XKFKSnp2Pnzp3YuXMn0tPTMXXq1BseU1VVhWHDhuH//u//rrvPvHnzsG3bNmzevBkHDhxAZWUlJk6cCKPReEvnJiIiIuoIkrhnLiMjA3369EFycjJiYmIAAMnJyYiLi8PZs2cRHh5+w+Nzc3MRGhqKtLQ0DBo0yLJdo9HAx8cHn332GSZPngwAuHLlCoKCgrBjxw6MGzfuls9dj/fMERERUXuQxMhcUlISVCqVpUwBQGxsLFQqFQ4dOtTq901NTUVdXR0SEhIs2wIDA9GvXz/L+7bXuYmIiIjagiTmWlCr1fD19W203dfXF2q1+pbe18nJCZ6eng22+/n5Wd63tefW6XTQ6X5bIUCr1bY6JxEREdH1iDoyt2TJEshkshu+jh49CgBNLrskCEK7LGD+x/dtzbmXLl1qeWBCpVIhKCiozXMSERERiToyN3v2bDz66KM33CckJAQnTpxAYWFho68VFxfDz8+v1ef39/eHXq/H1atXG4zOFRUVIT4+3rJPa869aNEiLFiwwPJnrVbLQkdERERtTtQy5+3tDW9v75vuFxcXB41Gg8OHD2Po0KEAgJSUFGg0Gkvpao2oqCg4OjoiMTERjzzyCACgoKAAp06dwptvvnlL51YqlVAqla3ORkRERNQckniaFQDGjx+PK1eu4IMPPgAAPPPMMwgODsZ3331n2SciIgJLly7FAw88AAAoKytDXl4erly5ggkTJmDz5s0IDw+Hv78//P39AQB/+ctf8P333+OTTz6Bl5cXFi5ciNLSUqSmpkKhUDT73DfDp1mJiIioPUjiaVYA2LBhA/r374+EhAQkJCRgwIAB+Oyzzxrsc+7cOWg0Gsuft2/fjsGDB2PChAkAgEcffRSDBw/G6tWrLfu88847uP/++/HII49g2LBhcHV1xXfffWcpcs09NxEREZEYJDMyJ3UcmSMiIqL2IJmROSIiIiJqjGWOiIiISMJY5oiIiIgkjGWOiIiISMJY5oiIiIgkjGWOiIiISMJY5oiIiIgkjPPMdRBBEFBRUQF3d3fIZDKx4xAREZGNYJkjIiIikjBeZiUiIiKSMJY5IiIiIgljmSMiIiKSMJY5IiIiIgljmSMiIiKSMJY5IiIiIgljmSMiIiKSsP8Hg/f8HrmOeIsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7f4f47ca3250>"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,expr.subs(p,sqrt(3)/6+Rational(1,2)),(p,0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "81d4eae5",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function primerange in module sympy.ntheory.generate:\n",
      "\n",
      "primerange(a, b=None)\n",
      "    Generate a list of all prime numbers in the range [2, a),\n",
      "    or [a, b).\n",
      "    \n",
      "    If the range exists in the default sieve, the values will\n",
      "    be returned from there; otherwise values will be returned\n",
      "    but will not modify the sieve.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import primerange, prime\n",
      "    \n",
      "    All primes less than 19:\n",
      "    \n",
      "    >>> list(primerange(19))\n",
      "    [2, 3, 5, 7, 11, 13, 17]\n",
      "    \n",
      "    All primes greater than or equal to 7 and less than 19:\n",
      "    \n",
      "    >>> list(primerange(7, 19))\n",
      "    [7, 11, 13, 17]\n",
      "    \n",
      "    All primes through the 10th prime\n",
      "    \n",
      "    >>> list(primerange(prime(10) + 1))\n",
      "    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n",
      "    \n",
      "    The Sieve method, primerange, is generally faster but it will\n",
      "    occupy more memory as the sieve stores values. The default\n",
      "    instance of Sieve, named sieve, can be used:\n",
      "    \n",
      "    >>> from sympy import sieve\n",
      "    >>> list(sieve.primerange(1, 30))\n",
      "    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n",
      "    \n",
      "    Notes\n",
      "    =====\n",
      "    \n",
      "    Some famous conjectures about the occurrence of primes in a given\n",
      "    range are [1]:\n",
      "    \n",
      "    - Twin primes: though often not, the following will give 2 primes\n",
      "                an infinite number of times:\n",
      "                    primerange(6*n - 1, 6*n + 2)\n",
      "    - Legendre's: the following always yields at least one prime\n",
      "                    primerange(n**2, (n+1)**2+1)\n",
      "    - Bertrand's (proven): there is always a prime in the range\n",
      "                    primerange(n, 2*n)\n",
      "    - Brocard's: there are at least four primes in the range\n",
      "                    primerange(prime(n)**2, prime(n+1)**2)\n",
      "    \n",
      "    The average gap between primes is log(n) [2]; the gap between\n",
      "    primes can be arbitrarily large since sequences of composite\n",
      "    numbers are arbitrarily large, e.g. the numbers in the sequence\n",
      "    n! + 2, n! + 3 ... n! + n are all composite.\n",
      "    \n",
      "    See Also\n",
      "    ========\n",
      "    \n",
      "    prime : Return the nth prime\n",
      "    nextprime : Return the ith prime greater than n\n",
      "    prevprime : Return the largest prime smaller than n\n",
      "    randprime : Returns a random prime in a given range\n",
      "    primorial : Returns the product of primes based on condition\n",
      "    Sieve.primerange : return range from already computed primes\n",
      "                       or extend the sieve to contain the requested\n",
      "                       range.\n",
      "    \n",
      "    References\n",
      "    ==========\n",
      "    \n",
      "    .. [1] https://en.wikipedia.org/wiki/Prime_number\n",
      "    .. [2] http://primes.utm.edu/notes/gaps.html\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(primerange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "f7e65f40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 13, 17, 19]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(primerange(10,21))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "1e245fad",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_a=[0.06,0.26,0.42,0.18,0.08]\n",
    "data_b=[55,65,75,85,95]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "4e390a3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}74.6\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([[74.6]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix(data_a).T*Matrix(data_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "ccd363e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.793103448275861"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "313/29"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "c39cc838",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140.3103448275862"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "313/29*13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "082effda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "60/7.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "2447aa37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "90/7.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "7749fdec",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(2*n+1)*3**(-n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "e696d638",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7f4f47d3ddc0>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,0.1,(n,1,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "e626b66c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import Binomial,Hypergeometric,density,E,P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "3d795e08",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function Binomial in module sympy.stats.frv_types:\n",
      "\n",
      "Binomial(name, n, p, succ=1, fail=0)\n",
      "    Create a Finite Random Variable representing a binomial distribution.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    n : Positive Integer\n",
      "      Represents number of trials\n",
      "    p : Rational Number between 0 and 1\n",
      "      Represents probability of success\n",
      "    succ : Integer/symbol/string\n",
      "      Represents event of success, by default is 1\n",
      "    fail : Integer/symbol/string\n",
      "      Represents event of failure, by default is 0\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy.stats import Binomial, density\n",
      "    >>> from sympy import S, Symbol\n",
      "    \n",
      "    >>> X = Binomial('X', 4, S.Half) # Four \"coin flips\"\n",
      "    >>> density(X).dict\n",
      "    {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}\n",
      "    \n",
      "    >>> n = Symbol('n', positive=True, integer=True)\n",
      "    >>> p = Symbol('p', positive=True)\n",
      "    >>> X = Binomial('X', n, S.Half) # n \"coin flips\"\n",
      "    >>> density(X).dict\n",
      "    Density(BinomialDistribution(n, 1/2, 1, 0))\n",
      "    >>> density(X).dict.subs(n, 4).doit()\n",
      "    {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16}\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    RandomSymbol\n",
      "    \n",
      "    References\n",
      "    ==========\n",
      "    \n",
      "    .. [1] https://en.wikipedia.org/wiki/Binomial_distribution\n",
      "    .. [2] http://mathworld.wolfram.com/BinomialDistribution.html\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Binomial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "a22ba7d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Binomial(\"X\",3,Rational(3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "c9e7a612",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{81}{125}$"
      ],
      "text/plain": [
       "81/125"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(X>=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "bf00046a",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Hypergeometric(\"Y\",10,6,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "58478a9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 1/30, 1: 3/10, 2: 1/2, 3: 1/6}"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(Y).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "d3925be2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{9}{5}$"
      ],
      "text/plain": [
       "9/5"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "4a1e44cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_a=[0.015,0.02,0.03,0.05,0.08,0.09,0.2]\n",
    "data_b=[4.1,5.6,5.6,5.5,5.7,6,5.8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "3ee36fa0",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.0615 & 0.084 & 0.084 & 0.0825 & 0.0855 & 0.09 & 0.087\\\\0.082 & 0.112 & 0.112 & 0.11 & 0.114 & 0.12 & 0.116\\\\0.123 & 0.168 & 0.168 & 0.165 & 0.171 & 0.18 & 0.174\\\\0.205 & 0.28 & 0.28 & 0.275 & 0.285 & 0.3 & 0.29\\\\0.328 & 0.448 & 0.448 & 0.44 & 0.456 & 0.48 & 0.464\\\\0.369 & 0.504 & 0.504 & 0.495 & 0.513 & 0.54 & 0.522\\\\0.82 & 1.12 & 1.12 & 1.1 & 1.14 & 1.2 & 1.16\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[0.0615, 0.084, 0.084, 0.0825, 0.0855, 0.09, 0.087],\n",
       "[ 0.082, 0.112, 0.112,   0.11,  0.114, 0.12, 0.116],\n",
       "[ 0.123, 0.168, 0.168,  0.165,  0.171, 0.18, 0.174],\n",
       "[ 0.205,  0.28,  0.28,  0.275,  0.285,  0.3,  0.29],\n",
       "[ 0.328, 0.448, 0.448,   0.44,  0.456, 0.48, 0.464],\n",
       "[ 0.369, 0.504, 0.504,  0.495,  0.513, 0.54, 0.522],\n",
       "[  0.82,  1.12,  1.12,    1.1,   1.14,  1.2,  1.16]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix(data_a)*Matrix(data_b).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "5822282f",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Hypergeometric(\"Y\",7,2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "2511ef05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 10/21, 1: 10/21, 2: 1/21}"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(Y).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "51bcc2dd",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4}{7}$"
      ],
      "text/plain": [
       "4/7"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "760c05ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Hypergeometric(\"Y\",9,4,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "45d36fee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 5/42, 1: 10/21, 2: 5/14, 3: 1/21}"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(Y).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "44c5d28c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4}{3}$"
      ],
      "text/plain": [
       "4/3"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "81d095ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import Normal,variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "053aa8b7",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function variance in module sympy.stats.rv_interface:\n",
      "\n",
      "variance(X, condition=None, **kwargs)\n",
      "    Variance of a random expression.\n",
      "    \n",
      "    .. math::\n",
      "        variance(X) = E((X-E(X))^{2})\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy.stats import Die, Bernoulli, variance\n",
      "    >>> from sympy import simplify, Symbol\n",
      "    \n",
      "    >>> X = Die('X', 6)\n",
      "    >>> p = Symbol('p')\n",
      "    >>> B = Bernoulli('B', p, 1, 0)\n",
      "    \n",
      "    >>> variance(2*X)\n",
      "    35/3\n",
      "    \n",
      "    >>> simplify(variance(B))\n",
      "    p*(1 - p)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(variance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "64b2ff2f",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function Normal in module sympy.stats.crv_types:\n",
      "\n",
      "Normal(name, mean, std)\n",
      "    Create a continuous random variable with a Normal distribution.\n",
      "    \n",
      "    Explanation\n",
      "    ===========\n",
      "    \n",
      "    The density of the Normal distribution is given by\n",
      "    \n",
      "    .. math::\n",
      "        f(x) := \\frac{1}{\\sigma\\sqrt{2\\pi}} e^{ -\\frac{(x-\\mu)^2}{2\\sigma^2} }\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    mu : Real number or a list representing the mean or the mean vector\n",
      "    sigma : Real number or a positive definite square matrix,\n",
      "         :math:`\\sigma^2 > 0` the variance\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    RandomSymbol\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy.stats import Normal, density, E, std, cdf, skewness, quantile, marginal_distribution\n",
      "    >>> from sympy import Symbol, simplify, pprint\n",
      "    \n",
      "    >>> mu = Symbol(\"mu\")\n",
      "    >>> sigma = Symbol(\"sigma\", positive=True)\n",
      "    >>> z = Symbol(\"z\")\n",
      "    >>> y = Symbol(\"y\")\n",
      "    >>> p = Symbol(\"p\")\n",
      "    >>> X = Normal(\"x\", mu, sigma)\n",
      "    \n",
      "    >>> density(X)(z)\n",
      "    sqrt(2)*exp(-(-mu + z)**2/(2*sigma**2))/(2*sqrt(pi)*sigma)\n",
      "    \n",
      "    >>> C = simplify(cdf(X))(z) # it needs a little more help...\n",
      "    >>> pprint(C, use_unicode=False)\n",
      "       /  ___          \\\n",
      "       |\\/ 2 *(-mu + z)|\n",
      "    erf|---------------|\n",
      "       \\    2*sigma    /   1\n",
      "    -------------------- + -\n",
      "             2             2\n",
      "    \n",
      "    >>> quantile(X)(p)\n",
      "    mu + sqrt(2)*sigma*erfinv(2*p - 1)\n",
      "    \n",
      "    >>> simplify(skewness(X))\n",
      "    0\n",
      "    \n",
      "    >>> X = Normal(\"x\", 0, 1) # Mean 0, standard deviation 1\n",
      "    >>> density(X)(z)\n",
      "    sqrt(2)*exp(-z**2/2)/(2*sqrt(pi))\n",
      "    \n",
      "    >>> E(2*X + 1)\n",
      "    1\n",
      "    \n",
      "    >>> simplify(std(2*X + 1))\n",
      "    2\n",
      "    \n",
      "    >>> m = Normal('X', [1, 2], [[2, 1], [1, 2]])\n",
      "    >>> pprint(density(m)(y, z), use_unicode=False)\n",
      "              2          2\n",
      "             y    y*z   z\n",
      "           - -- + --- - -- + z - 1\n",
      "      ___    3     3    3\n",
      "    \\/ 3 *e\n",
      "    ------------------------------\n",
      "                 6*pi\n",
      "    \n",
      "    >>> marginal_distribution(m, m[0])(1)\n",
      "     1/(2*sqrt(pi))\n",
      "    \n",
      "    \n",
      "    References\n",
      "    ==========\n",
      "    \n",
      "    .. [1] https://en.wikipedia.org/wiki/Normal_distribution\n",
      "    .. [2] http://mathworld.wolfram.com/NormalDistributionFunction.html\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Normal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "249b7c1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Normal(\"X\",100,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "13106342",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.839994848036913$"
      ],
      "text/plain": [
       "0.839994848036913"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(P(X<124)-P(X<=92))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "3df2befd",
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport excel_function_package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "82d17f28",
   "metadata": {},
   "outputs": [],
   "source": [
    "from excel_function_package.stats import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "b71aaf71",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_x=[87,87,88,92,95,97,98,99,103,104]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "682d4829",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "95.0"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "average(data_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "94a5d060",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6.0$"
      ],
      "text/plain": [
       "6.00000000000000"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(varp(data_x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "bc850401",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Normal(\"X\",95,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "a4c0dd56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.0227501319481792$"
      ],
      "text/plain": [
       "0.0227501319481792"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(P(X>107))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "01837248",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Binomial(\"Y\",10,N(P(X>107)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "64be9086",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.889302537780786$"
      ],
      "text/plain": [
       "0.889302537780786"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variance(2*Y+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "61d53312",
   "metadata": {},
   "outputs": [],
   "source": [
    "check=0.02275"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "e757d9d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.222324375$"
      ],
      "text/plain": [
       "0.222324375000000"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(10)*(1-check)*check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "144bf4de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.8892975$"
      ],
      "text/plain": [
       "0.889297500000000"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "60f5dd52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8892"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.2223*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "1420ab96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3.4135$"
      ],
      "text/plain": [
       "3.41350000000000"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(5)*0.6827"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "fbb5e754",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3.413444745$"
      ],
      "text/plain": [
       "3.41344474500000"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(5)*0.682688949"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "89e87293",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class erfc in module sympy.functions.special.error_functions:\n",
      "\n",
      "class erfc(sympy.core.function.Function)\n",
      " |  erfc(arg)\n",
      " |  \n",
      " |  Complementary Error Function.\n",
      " |  \n",
      " |  Explanation\n",
      " |  ===========\n",
      " |  \n",
      " |  The function is defined as:\n",
      " |  \n",
      " |  .. math ::\n",
      " |      \\mathrm{erfc}(x) = \\frac{2}{\\sqrt{\\pi}} \\int_x^\\infty e^{-t^2} \\mathrm{d}t\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import I, oo, erfc\n",
      " |  >>> from sympy.abc import z\n",
      " |  \n",
      " |  Several special values are known:\n",
      " |  \n",
      " |  >>> erfc(0)\n",
      " |  1\n",
      " |  >>> erfc(oo)\n",
      " |  0\n",
      " |  >>> erfc(-oo)\n",
      " |  2\n",
      " |  >>> erfc(I*oo)\n",
      " |  -oo*I\n",
      " |  >>> erfc(-I*oo)\n",
      " |  oo*I\n",
      " |  \n",
      " |  The error function obeys the mirror symmetry:\n",
      " |  \n",
      " |  >>> from sympy import conjugate\n",
      " |  >>> conjugate(erfc(z))\n",
      " |  erfc(conjugate(z))\n",
      " |  \n",
      " |  Differentiation with respect to $z$ is supported:\n",
      " |  \n",
      " |  >>> from sympy import diff\n",
      " |  >>> diff(erfc(z), z)\n",
      " |  -2*exp(-z**2)/sqrt(pi)\n",
      " |  \n",
      " |  It also follows\n",
      " |  \n",
      " |  >>> erfc(-z)\n",
      " |  2 - erfc(z)\n",
      " |  \n",
      " |  We can numerically evaluate the complementary error function to arbitrary\n",
      " |  precision on the whole complex plane:\n",
      " |  \n",
      " |  >>> erfc(4).evalf(30)\n",
      " |  0.0000000154172579002800188521596734869\n",
      " |  \n",
      " |  >>> erfc(4*I).evalf(30)\n",
      " |  1.0 - 1296959.73071763923152794095062*I\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  erf: Gaussian error function.\n",
      " |  erfi: Imaginary error function.\n",
      " |  erf2: Two-argument error function.\n",
      " |  erfinv: Inverse error function.\n",
      " |  erfcinv: Inverse Complementary error function.\n",
      " |  erf2inv: Inverse two-argument error function.\n",
      " |  \n",
      " |  References\n",
      " |  ==========\n",
      " |  \n",
      " |  .. [1] https://en.wikipedia.org/wiki/Error_function\n",
      " |  .. [2] http://dlmf.nist.gov/7\n",
      " |  .. [3] http://mathworld.wolfram.com/Erfc.html\n",
      " |  .. [4] http://functions.wolfram.com/GammaBetaErf/Erfc\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      erfc\n",
      " |      sympy.core.function.Function\n",
      " |      sympy.core.function.Application\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  as_real_imag = real_to_real_as_real_imag(self, deep=True, **hints)\n",
      " |      # Helper function\n",
      " |  \n",
      " |  fdiff(self, argindex=1)\n",
      " |      Returns the first derivative of the function.\n",
      " |  \n",
      " |  inverse(self, argindex=1)\n",
      " |      Returns the inverse of this function.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  eval(arg) from sympy.core.function.FunctionClass\n",
      " |      Returns a canonical form of cls applied to arguments args.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The eval() method is called when the class cls is about to be\n",
      " |      instantiated and it should return either some simplified instance\n",
      " |      (possible of some other class), or if the class cls should be\n",
      " |      unmodified, return None.\n",
      " |      \n",
      " |      Examples of eval() for the function \"sign\"\n",
      " |      ---------------------------------------------\n",
      " |      \n",
      " |      .. code-block:: python\n",
      " |      \n",
      " |          @classmethod\n",
      " |          def eval(cls, arg):\n",
      " |              if arg is S.NaN:\n",
      " |                  return S.NaN\n",
      " |              if arg.is_zero: return S.Zero\n",
      " |              if arg.is_positive: return S.One\n",
      " |              if arg.is_negative: return S.NegativeOne\n",
      " |              if isinstance(arg, Mul):\n",
      " |                  coeff, terms = arg.as_coeff_Mul(rational=True)\n",
      " |                  if coeff is not S.One:\n",
      " |                      return cls(coeff) * cls(terms)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  taylor_term(n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  unbranched = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  as_base_exp(self)\n",
      " |      Returns the method as the 2-tuple (base, exponent).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  class_key() from sympy.core.function.FunctionClass\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  is_singular(a) from sympy.core.function.FunctionClass\n",
      " |      Tests whether the argument is an essential singularity\n",
      " |      or a branch point, or the functions is non-holomorphic.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  __new__(cls, *args, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  is_Function = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __abs__(self)\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None)\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_coeff_add(self, *deps)\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |      \n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |      \n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |  \n",
      " |  as_coeff_exponent(self, x)\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, **kwargs)\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0. If an expression is\n",
      " |      not an Add it is considered to have a single term.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |      \n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |      \n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |      \n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |      \n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |      \n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |      \n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |      \n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |      \n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |      \n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |      \n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint)\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      .separatevars(), .expand(log=True), sympy.core.add.Add.as_two_terms(),\n",
      " |      sympy.core.mul.Mul.as_two_terms(), .as_coeff_add(), .as_coeff_mul()\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      expression -> a/b -> a, b\n",
      " |      \n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The number of terms upto which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] http://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it doesn't, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      is_rational_function()\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but gives only an Order term\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      O(log(x)**2)\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The number of terms upto which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |      \n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |      \n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |      \n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |      \n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |      \n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |      \n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> int\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself doesn't match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace lambda rule, **_\n",
      " |      # Function needs args so we define a property that returns\n",
      " |      # a function that takes args...and then use that function\n",
      " |      # to return the right value\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.function.FunctionClass\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Don't override .args() from Basic (so that it's easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'Tuple[Basic, ...]', '_mhash': 'Any', 'kin...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  kind = UndefinedKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(erfc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "242b6c81",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class erf in module sympy.functions.special.error_functions:\n",
      "\n",
      "class erf(sympy.core.function.Function)\n",
      " |  erf(arg)\n",
      " |  \n",
      " |  The Gauss error function.\n",
      " |  \n",
      " |  Explanation\n",
      " |  ===========\n",
      " |  \n",
      " |  This function is defined as:\n",
      " |  \n",
      " |  .. math ::\n",
      " |      \\mathrm{erf}(x) = \\frac{2}{\\sqrt{\\pi}} \\int_0^x e^{-t^2} \\mathrm{d}t.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import I, oo, erf\n",
      " |  >>> from sympy.abc import z\n",
      " |  \n",
      " |  Several special values are known:\n",
      " |  \n",
      " |  >>> erf(0)\n",
      " |  0\n",
      " |  >>> erf(oo)\n",
      " |  1\n",
      " |  >>> erf(-oo)\n",
      " |  -1\n",
      " |  >>> erf(I*oo)\n",
      " |  oo*I\n",
      " |  >>> erf(-I*oo)\n",
      " |  -oo*I\n",
      " |  \n",
      " |  In general one can pull out factors of -1 and $I$ from the argument:\n",
      " |  \n",
      " |  >>> erf(-z)\n",
      " |  -erf(z)\n",
      " |  \n",
      " |  The error function obeys the mirror symmetry:\n",
      " |  \n",
      " |  >>> from sympy import conjugate\n",
      " |  >>> conjugate(erf(z))\n",
      " |  erf(conjugate(z))\n",
      " |  \n",
      " |  Differentiation with respect to $z$ is supported:\n",
      " |  \n",
      " |  >>> from sympy import diff\n",
      " |  >>> diff(erf(z), z)\n",
      " |  2*exp(-z**2)/sqrt(pi)\n",
      " |  \n",
      " |  We can numerically evaluate the error function to arbitrary precision\n",
      " |  on the whole complex plane:\n",
      " |  \n",
      " |  >>> erf(4).evalf(30)\n",
      " |  0.999999984582742099719981147840\n",
      " |  \n",
      " |  >>> erf(-4*I).evalf(30)\n",
      " |  -1296959.73071763923152794095062*I\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  erfc: Complementary error function.\n",
      " |  erfi: Imaginary error function.\n",
      " |  erf2: Two-argument error function.\n",
      " |  erfinv: Inverse error function.\n",
      " |  erfcinv: Inverse Complementary error function.\n",
      " |  erf2inv: Inverse two-argument error function.\n",
      " |  \n",
      " |  References\n",
      " |  ==========\n",
      " |  \n",
      " |  .. [1] https://en.wikipedia.org/wiki/Error_function\n",
      " |  .. [2] http://dlmf.nist.gov/7\n",
      " |  .. [3] http://mathworld.wolfram.com/Erf.html\n",
      " |  .. [4] http://functions.wolfram.com/GammaBetaErf/Erf\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      erf\n",
      " |      sympy.core.function.Function\n",
      " |      sympy.core.function.Application\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  as_real_imag = real_to_real_as_real_imag(self, deep=True, **hints)\n",
      " |      # Helper function\n",
      " |  \n",
      " |  fdiff(self, argindex=1)\n",
      " |      Returns the first derivative of the function.\n",
      " |  \n",
      " |  inverse(self, argindex=1)\n",
      " |      Returns the inverse of this function.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  eval(arg) from sympy.core.function.FunctionClass\n",
      " |      Returns a canonical form of cls applied to arguments args.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The eval() method is called when the class cls is about to be\n",
      " |      instantiated and it should return either some simplified instance\n",
      " |      (possible of some other class), or if the class cls should be\n",
      " |      unmodified, return None.\n",
      " |      \n",
      " |      Examples of eval() for the function \"sign\"\n",
      " |      ---------------------------------------------\n",
      " |      \n",
      " |      .. code-block:: python\n",
      " |      \n",
      " |          @classmethod\n",
      " |          def eval(cls, arg):\n",
      " |              if arg is S.NaN:\n",
      " |                  return S.NaN\n",
      " |              if arg.is_zero: return S.Zero\n",
      " |              if arg.is_positive: return S.One\n",
      " |              if arg.is_negative: return S.NegativeOne\n",
      " |              if isinstance(arg, Mul):\n",
      " |                  coeff, terms = arg.as_coeff_Mul(rational=True)\n",
      " |                  if coeff is not S.One:\n",
      " |                      return cls(coeff) * cls(terms)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  taylor_term(n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  unbranched = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  as_base_exp(self)\n",
      " |      Returns the method as the 2-tuple (base, exponent).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  class_key() from sympy.core.function.FunctionClass\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  is_singular(a) from sympy.core.function.FunctionClass\n",
      " |      Tests whether the argument is an essential singularity\n",
      " |      or a branch point, or the functions is non-holomorphic.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from sympy.core.function.Function:\n",
      " |  \n",
      " |  __new__(cls, *args, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.function.Application:\n",
      " |  \n",
      " |  is_Function = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __abs__(self)\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __int__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None)\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_coeff_add(self, *deps)\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |      \n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |      \n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |  \n",
      " |  as_coeff_exponent(self, x)\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, **kwargs)\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0. If an expression is\n",
      " |      not an Add it is considered to have a single term.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      This method should recursively remove a Rational from all arguments\n",
      " |      and return that (content) and the new self (primitive). The content\n",
      " |      should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.\n",
      " |      The primitive need not be in canonical form and should try to preserve\n",
      " |      the underlying structure if possible (i.e. expand_mul should not be\n",
      " |      applied to self).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> eq = 2 + 2*x + 2*y*(3 + 3*y)\n",
      " |      \n",
      " |      The as_content_primitive function is recursive and retains structure:\n",
      " |      \n",
      " |      >>> eq.as_content_primitive()\n",
      " |      (2, x + 3*y*(y + 1) + 1)\n",
      " |      \n",
      " |      Integer powers will have Rationals extracted from the base:\n",
      " |      \n",
      " |      >>> ((2 + 6*x)**2).as_content_primitive()\n",
      " |      (4, (3*x + 1)**2)\n",
      " |      >>> ((2 + 6*x)**(2*y)).as_content_primitive()\n",
      " |      (1, (2*(3*x + 1))**(2*y))\n",
      " |      \n",
      " |      Terms may end up joining once their as_content_primitives are added:\n",
      " |      \n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (11, x*(y + 1))\n",
      " |      >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (9, x*(y + 1))\n",
      " |      >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()\n",
      " |      (1, 6.0*x*(y + 1) + 3*z*(y + 1))\n",
      " |      >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (121, x**2*(y + 1)**2)\n",
      " |      >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()\n",
      " |      (1, 4.84*x**2*(y + 1)**2)\n",
      " |      \n",
      " |      Radical content can also be factored out of the primitive:\n",
      " |      \n",
      " |      >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)\n",
      " |      (2, sqrt(2)*(1 + 2*sqrt(5)))\n",
      " |      \n",
      " |      If clear=False (default is True) then content will not be removed\n",
      " |      from an Add if it can be distributed to leave one or more\n",
      " |      terms with integer coefficients.\n",
      " |      \n",
      " |      >>> (x/2 + y).as_content_primitive()\n",
      " |      (1/2, x + 2*y)\n",
      " |      >>> (x/2 + y).as_content_primitive(clear=False)\n",
      " |      (1, x/2 + y)\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint)\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      .separatevars(), .expand(log=True), sympy.core.add.Add.as_two_terms(),\n",
      " |      sympy.core.mul.Mul.as_two_terms(), .as_coeff_add(), .as_coeff_mul()\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      expression -> a/b -> a, b\n",
      " |      \n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The number of terms upto which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] http://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it doesn't, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  invert(self, g, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      is_rational_function()\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but gives only an Order term\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      O(log(x)**2)\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The number of terms upto which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  is_number\n",
      " |      Returns True if ``self`` has no free symbols and no\n",
      " |      undefined functions (AppliedUndef, to be precise). It will be\n",
      " |      faster than ``if not self.free_symbols``, however, since\n",
      " |      ``is_number`` will fail as soon as it hits a free symbol\n",
      " |      or undefined function.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function, Integral, cos, sin, pi\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> f = Function('f')\n",
      " |      \n",
      " |      >>> x.is_number\n",
      " |      False\n",
      " |      >>> f(1).is_number\n",
      " |      False\n",
      " |      >>> (2*x).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, x)).is_number\n",
      " |      False\n",
      " |      >>> (2 + Integral(2, (x, 1, 2))).is_number\n",
      " |      True\n",
      " |      \n",
      " |      Not all numbers are Numbers in the SymPy sense:\n",
      " |      \n",
      " |      >>> pi.is_number, pi.is_Number\n",
      " |      (True, False)\n",
      " |      \n",
      " |      If something is a number it should evaluate to a number with\n",
      " |      real and imaginary parts that are Numbers; the result may not\n",
      " |      be comparable, however, since the real and/or imaginary part\n",
      " |      of the result may not have precision.\n",
      " |      \n",
      " |      >>> cos(1).is_number and cos(1).is_comparable\n",
      " |      True\n",
      " |      \n",
      " |      >>> z = cos(1)**2 + sin(1)**2 - 1\n",
      " |      >>> z.is_number\n",
      " |      True\n",
      " |      >>> z.is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.basic.Basic.is_comparable\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> int\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself doesn't match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace lambda rule, **_\n",
      " |      # Function needs args so we define a property that returns\n",
      " |      # a function that takes args...and then use that function\n",
      " |      # to return the right value\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.function.FunctionClass\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Don't override .args() from Basic (so that it's easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'Tuple[Basic, ...]', '_mhash': 'Any', 'kin...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  kind = UndefinedKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(erf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "2886dbe7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.441770171438842$"
      ],
      "text/plain": [
       "0.441770171438842"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(erfinv(0.3413444745)*sqrt(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "6555b3fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.441708718343124$"
      ],
      "text/plain": [
       "0.441708718343124"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(erfinv(0.3413)*sqrt(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "82b0fe21",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 11.1803398874989$"
      ],
      "text/plain": [
       "11.1803398874989"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(5*sqrt(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "b925dccf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.318102314864399"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5/0.441770171438842"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "a73de91e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.319900384876613"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5/0.4417"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "2d11e04b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{117}{125}$"
      ],
      "text/plain": [
       "117/125"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1-(Rational(2,5))**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "ce7e25e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Hypergeometric(\"X\",7,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "21fa4b17",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 4/35, 1: 18/35, 2: 12/35, 3: 1/35}"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(X).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "61e303ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Hypergeometric(\"X\",10,6,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "fbe1f8e8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 1/30, 1: 3/10, 2: 1/2, 3: 1/6}"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(X).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "5884198c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{9}{5}$"
      ],
      "text/plain": [
       "9/5"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "94532b91",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Binomial(\"X\",15,Rational(1,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "ce042977",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(Eq(X,4))>P(Eq(X,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "44441ead",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.02275$"
      ],
      "text/plain": [
       "0.0227500000000000"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1-0.9545)/S(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "30e15ad0",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Binomial(\"X\",100,Rational(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "296635dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.0284439668204904$"
      ],
      "text/plain": [
       "0.0284439668204904"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(P(X<=40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "19e7d718",
   "metadata": {},
   "outputs": [],
   "source": [
    "A=solveset((x+1)/(x-2)<=0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "dd776206",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-1, 2\\right)$"
      ],
      "text/plain": [
       "Interval.Ropen(-1, 2)"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "20c1d882",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[1, 3\\right]$"
      ],
      "text/plain": [
       "Interval(1, 3)"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B=solveset(x**2-4*x+3<=0,x,Reals)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "ab035182",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[1, 2\\right)$"
      ],
      "text/plain": [
       "Interval.Ropen(1, 2)"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.intersect(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "ac14baa1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{1 - \\sqrt{a + 2}, \\sqrt{a + 2} + 1\\right\\}$"
      ],
      "text/plain": [
       "Intersection({1 - sqrt(a + 2), sqrt(a + 2) + 1}, Reals)"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(x**2-2*x-1-a,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "8735ea47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, -1\\right) \\cup \\left(3, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, -1), Interval.open(3, oo))"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(x**2-2*x-3>0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "id": "47ae0130",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-1, 2\\right) \\cup \\left(2, 6\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-1, 2), Interval.open(2, 6))"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset((x+10)/(x-2)**2>1,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "d5b3fa66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{-1 - \\frac{\\sqrt{a \\left(a - 3\\right)}}{a}, -1 + \\frac{\\sqrt{a \\left(a - 3\\right)}}{a}\\right\\}$"
      ],
      "text/plain": [
       "Intersection({-1 - sqrt(a*(a - 3))/a, -1 + sqrt(a*(a - 3))/a}, Reals)"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(a*x**2+2*a*x+3,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "92b51017",
   "metadata": {},
   "outputs": [],
   "source": [
    "check=list(nonlinsolve([x+y-(2*sqrt(2)+3)/4,(x+3*y)**2/(3*x+y)**2-2],[x,y]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "7fd9c260",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(simplify(check[0])[0],(Rational(1,8)+sqrt(2)/4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "a3501ab3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(simplify(check[0])[1],(Rational(5,8)+sqrt(2)/4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "84f005ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(\\sqrt{2} + 2\\right)^{2}}{\\left(1 + \\sqrt{2}\\right)^{2}}$"
      ],
      "text/plain": [
       "(sqrt(2) + 2)**2/(1 + sqrt(2))**2"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((x+3*y)**2/(3*x+y)**2).subs([(x,(Rational(1,8)+sqrt(2)/4)),(y,(Rational(5,8)+sqrt(2)/4))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "2d7863fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2$"
      ],
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7aac90a",
   "metadata": {},
   "source": [
    "### 2023年36+6文科第一卷3题错题校对"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "301c6564",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import FiniteRV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "8fad3de3",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=FiniteRV(\"X\",{3:S(0.25),4:S(0.3),5:S(0.2),6:S(0.25)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "68431751",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=FiniteRV(\"Y\",{3:S(0.15),4:S(0.25),5:S(0.35),6:S(0.25)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "b9b2d1c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{ 3 : 0.25, \\  4 : 0.3, \\  5 : 0.2, \\  6 : 0.25\\right\\}$"
      ],
      "text/plain": [
       "{3: 0.25, 4: 0.3, 5: 0.2, 6: 0.25}"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(X).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "81bc95c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{ 3 : 0.15, \\  4 : 0.25, \\  5 : 0.35, \\  6 : 0.25\\right\\}$"
      ],
      "text/plain": [
       "{3: 0.15, 4: 0.25, 5: 0.35, 6: 0.25}"
      ]
     },
     "execution_count": 263,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(Y).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "a4d3534a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.2475$"
      ],
      "text/plain": [
       "1.24750000000000"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variance(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "f3854a7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4.45$"
      ],
      "text/plain": [
       "4.45000000000000"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "id": "744d8f78",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.01$"
      ],
      "text/plain": [
       "1.01000000000000"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variance(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "id": "7fc202d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4.7$"
      ],
      "text/plain": [
       "4.70000000000000"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "id": "21f98239",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "id": "a1780423",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on _SpecialGenericAlias in module typing:\n",
      "\n",
      "typing.List\n",
      "    A generic version of list.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(List)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "id": "221c0d65",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "id": "48f2795a",
   "metadata": {},
   "outputs": [],
   "source": [
    "rot_matrix=Matrix([[cos(theta),-sin(theta)],[sin(theta),cos(theta)]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "id": "c87dac35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(\\theta \\right)} & - \\sin{\\left(\\theta \\right)}\\\\\\sin{\\left(\\theta \\right)} & \\cos{\\left(\\theta \\right)}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[cos(theta), -sin(theta)],\n",
       "[sin(theta),  cos(theta)]])"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rot_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "id": "d4a42441",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}x\\\\y\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[x],\n",
       "[y]])"
      ]
     },
     "execution_count": 279,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec=Matrix([x,y])\n",
    "vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "id": "919ed16f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}x \\cos{\\left(\\theta \\right)} - y \\sin{\\left(\\theta \\right)}\\\\x \\sin{\\left(\\theta \\right)} + y \\cos{\\left(\\theta \\right)}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[x*cos(theta) - y*sin(theta)],\n",
       "[x*sin(theta) + y*cos(theta)]])"
      ]
     },
     "execution_count": 290,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rot_matrix*vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "id": "c5391fde",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rot(m,theta):\n",
    "    rot_matrix=Matrix([[cos(theta),-sin(theta)],[sin(theta),cos(theta)]])\n",
    "    return rot_matrix*m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "id": "0589dfd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\sqrt{3}\\\\-1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[sqrt(3)],\n",
       "[     -1]])"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=Matrix([sqrt(3),-1])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "id": "f9be55d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1\\\\- \\sqrt{3}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[       1],\n",
       "[-sqrt(3)]])"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rot(A,-pi/6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "id": "0ba4f562",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 27.2271363311115$"
      ],
      "text/plain": [
       "27.2271363311115"
      ]
     },
     "execution_count": 298,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(26/3*pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83017d97",
   "metadata": {},
   "source": [
    "#### 2022年全国乙卷理科的3+1棋手问题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "id": "c5389233",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "id": "ae945a3d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game_list = [1,2,3]\n",
    "game_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "id": "b84fef11",
   "metadata": {},
   "outputs": [],
   "source": [
    "temp=game_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "id": "06d992bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "random.shuffle(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "id": "a5f3e0dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 3]"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "game_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "id": "f50744a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 3]"
      ]
     },
     "execution_count": 339,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "id": "bbf1a430",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle p_{1}$"
      ],
      "text/plain": [
       "p1"
      ]
     },
     "execution_count": 343,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1,p2,p3=symbols(\"p1,p2,p3\")\n",
    "p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "id": "0d334fcc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p1,p2,p3:  0.33376 , 0.33143 , 0.33481\n"
     ]
    }
   ],
   "source": [
    "n=100000\n",
    "p1=0\n",
    "p2=0\n",
    "p3=0\n",
    "for i in range(n):\n",
    "    temp=[1,2,3]\n",
    "    random.shuffle(temp)\n",
    "    if temp[1]==1:\n",
    "        p1+=1\n",
    "    elif temp[1]==2:\n",
    "        p2+=1\n",
    "    else:\n",
    "        p3+=1\n",
    "print(\"p1,p2,p3: \",p1/n,\",\",p2/n,\",\",p3/n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "id": "abdd2923",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 - i$"
      ],
      "text/plain": [
       "3 - I"
      ]
     },
     "execution_count": 353,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify((4+2*I)/(1+I))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "id": "3731f2d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -2.0 - 4.0 i$"
      ],
      "text/plain": [
       "-2.0 - 4.0*I"
      ]
     },
     "execution_count": 357,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(-10*I/(2+I))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 358,
   "id": "608e22a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{5}$"
      ],
      "text/plain": [
       "2*sqrt(5)"
      ]
     },
     "execution_count": 358,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-10*I/(2+I))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 359,
   "id": "56672090",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2} - \\frac{3 i}{2}$"
      ],
      "text/plain": [
       "1/2 - 3*I/2"
      ]
     },
     "execution_count": 359,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify((2-I)/(1+I))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 361,
   "id": "db296176",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "id": "f8ef0616",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=solveset(Eq((I**4+2*I)*z,4+3*I),z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "id": "9a66ff27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{\\left(1 - 2 i\\right) \\left(4 + 3 i\\right)}{5}\\right\\}$"
      ],
      "text/plain": [
       "{(1 - 2*I)*(4 + 3*I)/5}"
      ]
     },
     "execution_count": 372,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "id": "e619132e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 - i$"
      ],
      "text/plain": [
       "2 - I"
      ]
     },
     "execution_count": 371,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer.args[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "id": "5ce57043",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- i \\left(3 - 4 i\\right)\\right\\}$"
      ],
      "text/plain": [
       "{-I*(3 - 4*I)}"
      ]
     },
     "execution_count": 375,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(Eq(I*z,3-4*I),z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "id": "76c75884",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 5$"
      ],
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 376,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(_.args[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "id": "ee3baaef",
   "metadata": {},
   "outputs": [],
   "source": [
    "z0=1-2*I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "id": "f017b9cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "id": "bed76d12",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 384,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a in Reals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "id": "70cddef9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{\\left(1 - 2 i\\right) \\left(b + 1 - 2 i\\right)}{5}\\right\\}$"
      ],
      "text/plain": [
       "{-(1 - 2*I)*(b + 1 - 2*I)/5}"
      ]
     },
     "execution_count": 389,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(z0+a*conjugate(z0)+b,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "id": "f2cc9292",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer_a=_.args[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "id": "8ea170df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(1 - 2 i\\right) \\left(- b - 1 + 2 i\\right)}{5}$"
      ],
      "text/plain": [
       "(1 - 2*I)*(-b - 1 + 2*I)/5"
      ]
     },
     "execution_count": 397,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "id": "83c1d18d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 394,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer_a.subs(b,-2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "id": "5e06b041",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{z\\; \\middle|\\; z \\in \\mathbb{C} \\wedge z \\left(\\overline{z} + 2 i\\right) - 8 - 6 i = 0 \\right\\}$"
      ],
      "text/plain": [
       "ConditionSet(z, Eq(z*(conjugate(z) + 2*I) - 8 - 6*I, 0), Complexes)"
      ]
     },
     "execution_count": 400,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(Eq(z*(conjugate(z)+2*I),8+6*I),z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "id": "d39a54e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{1}{2} - \\frac{i}{2}\\right\\}$"
      ],
      "text/plain": [
       "{-1/2 - I/2}"
      ]
     },
     "execution_count": 401,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(Eq(z*(1-I),I**2022),z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "id": "ac936d88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{1}{2} + \\frac{i}{2}$"
      ],
      "text/plain": [
       "-1/2 + I/2"
      ]
     },
     "execution_count": 402,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conjugate(_.args[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "id": "9e7c9c43",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "id": "2cff2d63",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle i$"
      ],
      "text/plain": [
       "I"
      ]
     },
     "execution_count": 409,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp(pi/2*I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "id": "be0f00c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -0.989992496600445$"
      ],
      "text/plain": [
       "-0.989992496600445"
      ]
     },
     "execution_count": 414,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(re(exp(I*3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "id": "a88ffb53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.141120008059867$"
      ],
      "text/plain": [
       "0.141120008059867"
      ]
     },
     "execution_count": 415,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(im(exp(I*3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "id": "ece00bef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "execution_count": 418,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re(conjugate(exp(pi/3*I)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "id": "7f58eb5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\sqrt{3}}{2}$"
      ],
      "text/plain": [
       "-sqrt(3)/2"
      ]
     },
     "execution_count": 419,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im(conjugate(exp(pi/3*I)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "id": "37097d08",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "id": "296ca362",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import E,P,FiniteRV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 422,
   "id": "bbbd3181",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=FiniteRV(\"X\",{0:a,1:b,2:b/2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "id": "2eb3f534",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 b$"
      ],
      "text/plain": [
       "2*b"
      ]
     },
     "execution_count": 425,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 429,
   "id": "d40fea33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 b^{2} \\cdot \\left(1 - \\frac{3 b}{2}\\right) + b \\left(1 - 2 b\\right)^{2} + \\frac{b \\left(2 - 2 b\\right)^{2}}{2}$"
      ],
      "text/plain": [
       "4*b**2*(1 - 3*b/2) + b*(1 - 2*b)**2 + b*(2 - 2*b)**2/2"
      ]
     },
     "execution_count": 429,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(variance(X).subs(a,1-3*b/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "id": "86d073f5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b \\left(3 - 4 b\\right)$"
      ],
      "text/plain": [
       "b*(3 - 4*b)"
      ]
     },
     "execution_count": 428,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(variance(X).subs(a,1-3*b/2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "id": "cc2bca3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_a=[4,8,8]\n",
    "data_b=[0.9,0.7,0.4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "id": "ad1c5d04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.62\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([[0.62]])"
      ]
     },
     "execution_count": 432,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix(data_a).T*Matrix(data_b)/20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "id": "41d13cf1",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function probability in module sympy.stats.rv:\n",
      "\n",
      "probability(condition, given_condition=None, numsamples=None, evaluate=True, **kwargs)\n",
      "    Probability that a condition is true, optionally given a second condition.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    condition : Combination of Relationals containing RandomSymbols\n",
      "        The condition of which you want to compute the probability\n",
      "    given_condition : Combination of Relationals containing RandomSymbols\n",
      "        A conditional expression. P(X > 1, X > 0) is expectation of X > 1\n",
      "        given X > 0\n",
      "    numsamples : int\n",
      "        Enables sampling and approximates the probability with this many samples\n",
      "    evaluate : Bool (defaults to True)\n",
      "        In case of continuous systems return unevaluated integral\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy.stats import P, Die\n",
      "    >>> from sympy import Eq\n",
      "    >>> X, Y = Die('X', 6), Die('Y', 6)\n",
      "    >>> P(X > 3)\n",
      "    1/2\n",
      "    >>> P(Eq(X, 5), X > 2) # Probability that X == 5 given that X > 2\n",
      "    1/4\n",
      "    >>> P(X > Y)\n",
      "    5/12\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "id": "1713ea84",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_a=[0.3,0.3,0.4]\n",
    "data_b=[0.4,0.6,0.6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 435,
   "id": "274c154e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}0.54\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([[0.54]])"
      ]
     },
     "execution_count": 435,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix(data_a).T*Matrix(data_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 440,
   "id": "77d8bffc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2}{9}$"
      ],
      "text/plain": [
       "2/9"
      ]
     },
     "execution_count": 440,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Rational(12,54)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "id": "fefc7948",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{8} + 7 x^{7} y + 20 x^{6} y^{2} + 28 x^{5} y^{3} + 14 x^{4} y^{4} - 14 x^{3} y^{5} - 28 x^{2} y^{6} - 20 x y^{7} - 7 y^{8} - \\frac{y^{9}}{x}$"
      ],
      "text/plain": [
       "x**8 + 7*x**7*y + 20*x**6*y**2 + 28*x**5*y**3 + 14*x**4*y**4 - 14*x**3*y**5 - 28*x**2*y**6 - 20*x*y**7 - 7*y**8 - y**9/x"
      ]
     },
     "execution_count": 442,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((1-y/x)*(x+y)**8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "id": "3031e6a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import DiscreteMarkovChain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "id": "7b2807c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "T=Matrix([[Rational(1,3),Rational(2,3)],[Rational(2,3),Rational(1,3)]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "id": "67044ec4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\frac{1}{3} & \\frac{2}{3}\\\\\\frac{2}{3} & \\frac{1}{3}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1/3, 2/3],\n",
       "[2/3, 1/3]])"
      ]
     },
     "execution_count": 447,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 446,
   "id": "9f6961b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=DiscreteMarkovChain(\"Y\",[\"first\",\"second\"],T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 449,
   "id": "59bbb0c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "first,second=symbols(\"first,second\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 455,
   "id": "4d71cf2b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{first, second\\right\\}$"
      ],
      "text/plain": [
       "{first, second}"
      ]
     },
     "execution_count": 455,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.state_space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 456,
   "id": "4d8e194d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}\\frac{1}{3} & \\frac{2}{3}\\\\\\frac{2}{3} & \\frac{1}{3}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1/3, 2/3],\n",
       "[2/3, 1/3]])"
      ]
     },
     "execution_count": 456,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.transition_probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 459,
   "id": "d5d3a361",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2}{3}$"
      ],
      "text/plain": [
       "2/3"
      ]
     },
     "execution_count": 459,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "T[1,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 460,
   "id": "a86ae78a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Y[3]$"
      ],
      "text/plain": [
       "Y[3]"
      ]
     },
     "execution_count": 460,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 477,
   "id": "be6a06f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{P}\\left(Y[0] = 1\\right)$"
      ],
      "text/plain": [
       "Probability(Eq(Y[0], 1))"
      ]
     },
     "execution_count": 477,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(Eq(Y[0],1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 468,
   "id": "d1bacac4",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Hypergeometric(\"X\",15,5,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 469,
   "id": "0719c752",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 3/7, 1: 10/21, 2: 2/21}"
      ]
     },
     "execution_count": 469,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(X).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 470,
   "id": "2902dffb",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_X=[0,10,20,30,40,70,150]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 473,
   "id": "ac7d96fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_P=[81/256,27/64,27/256,27/256,3/128,3/128,1/256]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "id": "f5e30222",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}12.65625\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([[12.65625]])"
      ]
     },
     "execution_count": 474,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix(data_X).T*Matrix(data_P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "id": "10b782fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{405}{32}$"
      ],
      "text/plain": [
       "405/32"
      ]
     },
     "execution_count": 475,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Rational(12.65625)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 476,
   "id": "a8e31b6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\sqrt{2}}{2} + \\frac{\\sqrt{6}}{2}$"
      ],
      "text/plain": [
       "-sqrt(2)/2 + sqrt(6)/2"
      ]
     },
     "execution_count": 476,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*sin(pi/12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 480,
   "id": "ae2ba44c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\left(\\sin{\\left(y \\right)} + 1\\right) \\cos^{2}{\\left(x \\right)} = 2 \\sin{\\left(x \\right)} \\cos{\\left(x \\right)} \\cos{\\left(y \\right)}$"
      ],
      "text/plain": [
       "Eq(2*(sin(y) + 1)*cos(x)**2, 2*sin(x)*cos(x)*cos(y))"
      ]
     },
     "execution_count": 480,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(Eq((1+cos(2*x))*(1+sin(y)),sin(2*x)*cos(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 482,
   "id": "e8cde7f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( x, \\  y\\right)\\; \\middle|\\; \\left( x, \\  y\\right) \\in \\mathbb{C}^{2} \\wedge \\sin{\\left(x \\right)} + 3 \\sin{\\left(y \\right)} - 1 = 0 \\wedge \\cos{\\left(x \\right)} - 3 \\cos{\\left(y \\right)} - 2 \\sqrt{2} = 0 \\right\\}$"
      ],
      "text/plain": [
       "ConditionSet((x, y), Eq(sin(x) + 3*sin(y) - 1, 0) & Eq(cos(x) - 3*cos(y) - 2*sqrt(2), 0), ProductSet(Complexes, Complexes))"
      ]
     },
     "execution_count": 482,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([Eq(cos(x)-3*cos(y),2*sqrt(2)),Eq(sin(x)+3*sin(y),1)],[x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 483,
   "id": "a95ecb11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4 \\sin{\\left(x + \\frac{\\pi}{6} \\right)}}{3}$"
      ],
      "text/plain": [
       "4*sin(x + pi/6)/3"
      ]
     },
     "execution_count": 483,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(Rational(1,3)*sin(x+pi/6)+cos(x-pi/3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 487,
   "id": "1d0e3d51",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(x-3)*2**(1-Rational(2,5)*x)+2**Rational(12,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 488,
   "id": "9793f7ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2 \\cdot 2^{1 - \\frac{2 x}{5}} \\left(x - 3\\right) \\log{\\left(2 \\right)}}{5} + 2^{1 - \\frac{2 x}{5}}$"
      ],
      "text/plain": [
       "-2*2**(1 - 2*x/5)*(x - 3)*log(2)/5 + 2**(1 - 2*x/5)"
      ]
     },
     "execution_count": 488,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 490,
   "id": "3376ee24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.693147180559945$"
      ],
      "text/plain": [
       "0.693147180559945"
      ]
     },
     "execution_count": 490,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(ln(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 492,
   "id": "6b9f36b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 7.38905609893065$"
      ],
      "text/plain": [
       "7.38905609893065"
      ]
     },
     "execution_count": 492,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(exp(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 494,
   "id": "38ee84ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.1359$"
      ],
      "text/plain": [
       "0.135900000000000"
      ]
     },
     "execution_count": 494,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0.9545-0.6827)/S(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 495,
   "id": "8be0713c",
   "metadata": {},
   "outputs": [],
   "source": [
    "eq1=Eq(x*(1-x)+(1+x)**2,Rational(32,7)*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 497,
   "id": "754a4b6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{7}{11}\\right\\}$"
      ],
      "text/plain": [
       "{7/11}"
      ]
     },
     "execution_count": 497,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(eq1,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 501,
   "id": "6047b356",
   "metadata": {},
   "outputs": [],
   "source": [
    "t=symbols(\"t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 504,
   "id": "a913ff0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(4+m**2)*(3*t**2-12)/(3*m**2+4)+m*(t+2)*(-6*m*t)/(3*m**2+4)+(t+2)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 505,
   "id": "60b749ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{6 m^{2} t \\left(t + 2\\right)}{3 m^{2} + 4} + \\frac{\\left(m^{2} + 4\\right) \\left(3 t^{2} - 12\\right)}{3 m^{2} + 4} + \\left(t + 2\\right)^{2}$"
      ],
      "text/plain": [
       "-6*m**2*t*(t + 2)/(3*m**2 + 4) + (m**2 + 4)*(3*t**2 - 12)/(3*m**2 + 4) + (t + 2)**2"
      ]
     },
     "execution_count": 505,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 506,
   "id": "a530a41f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{16 \\left(t^{2} + t - 2\\right)}{3 m^{2} + 4}$"
      ],
      "text/plain": [
       "16*(t**2 + t - 2)/(3*m**2 + 4)"
      ]
     },
     "execution_count": 506,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 508,
   "id": "2b291374",
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport function_calculator_package.extreme_points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 509,
   "id": "2d6d72c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from function_calculator_package.extreme_points import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 510,
   "id": "bd1bce5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function function_tangent in module function_calculator_package.extreme_points:\n",
      "\n",
      "function_tangent(f, x, x_0=0, coordinate=(x, y))\n",
      "    this function will return the f(function of x)'s tangent equation at x=x_0.\n",
      "    \n",
      "    if you don't point out the the x_0,it will be 0.\n",
      "    if you don't point out the coordinate's symbols, it will be xOy coordinate.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(function_tangent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 511,
   "id": "c70ee722",
   "metadata": {},
   "outputs": [],
   "source": [
    "fun_f=exp(x)\n",
    "fun_g=ln(x)+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 512,
   "id": "9e0ab767",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle y = \\left(- t + x + 1\\right) e^{t}$"
      ],
      "text/plain": [
       "Eq(y, (-t + x + 1)*exp(t))"
      ]
     },
     "execution_count": 512,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_tangent(fun_f,x,t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 513,
   "id": "fefab3fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle y = \\log{\\left(t \\right)} + 1 + \\frac{x}{t}$"
      ],
      "text/plain": [
       "Eq(y, log(t) + 1 + x/t)"
      ]
     },
     "execution_count": 513,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_tangent(fun_g,x,t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 522,
   "id": "199a1441",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\infty$"
      ],
      "text/plain": [
       "oo"
      ]
     },
     "execution_count": 522,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+oo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 523,
   "id": "7e2e559a",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_a=[10,8,7,6,3,2]\n",
    "data_b=[1,4,5,9,9,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 526,
   "id": "098f38cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 6, 7, 8, 10]"
      ]
     },
     "execution_count": 526,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_a.sort()\n",
    "data_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 527,
   "id": "20b98cca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 5, 8, 9, 9]"
      ]
     },
     "execution_count": 527,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_b.sort()\n",
    "data_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 530,
   "id": "274332fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{23}{3}$"
      ],
      "text/plain": [
       "23/3"
      ]
     },
     "execution_count": 530,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Rational(varp(data_a)).limit_denominator(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 531,
   "id": "71e4b697",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{26}{3}$"
      ],
      "text/plain": [
       "26/3"
      ]
     },
     "execution_count": 531,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Rational(varp(data_b)).limit_denominator(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 545,
   "id": "b1083c96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.513342083279505$"
      ],
      "text/plain": [
       "0.513342083279505"
      ]
     },
     "execution_count": 545,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(0.95)**13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 544,
   "id": "9b93a425",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.9025$"
      ],
      "text/plain": [
       "0.902500000000000"
      ]
     },
     "execution_count": 544,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(0.95)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 534,
   "id": "f4ce578e",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Binomial(\"X\",15,Rational(5,100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 536,
   "id": "9e7d52e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.13475229686087$"
      ],
      "text/plain": [
       "0.134752296860870"
      ]
     },
     "execution_count": 536,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(P(Eq(X,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "id": "a413044b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3}{4}$"
      ],
      "text/plain": [
       "3/4"
      ]
     },
     "execution_count": 538,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sympy.stats import E\n",
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 540,
   "id": "bf886474",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{57}{80}$"
      ],
      "text/plain": [
       "57/80"
      ]
     },
     "execution_count": 540,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variance(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 541,
   "id": "1b8a364e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.7125$"
      ],
      "text/plain": [
       "0.712500000000000"
      ]
     },
     "execution_count": 541,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(variance(X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 551,
   "id": "e688714d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 \\neq x$"
      ],
      "text/plain": [
       "Ne(1, x)"
      ]
     },
     "execution_count": 551,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ne(1,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e3063ea",
   "metadata": {},
   "source": [
    "$ AB \\perp CD $"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c5d5cc7",
   "metadata": {},
   "source": [
    "$ \\angle $"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d9e63f6",
   "metadata": {},
   "source": [
    "$ \\to $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 552,
   "id": "45b0f5d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1011}{2024}$"
      ],
      "text/plain": [
       "1011/2024"
      ]
     },
     "execution_count": 552,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Rational(1,2)-Rational(1,2024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 554,
   "id": "e10b8225",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Binomial(\"X\",3,Rational(13,15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 555,
   "id": "90e743f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{52}{1125}$"
      ],
      "text/plain": [
       "52/1125"
      ]
     },
     "execution_count": 555,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(Eq(X,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 556,
   "id": "42ba1939",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{13}{3000}$"
      ],
      "text/plain": [
       "13/3000"
      ]
     },
     "execution_count": 556,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(Eq(X,1))*3/32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "id": "c4ba3b6b",
   "metadata": {},
   "outputs": [],
   "source": [
    " X=FiniteRV(\"X\",{Rational(51/2):0.001,Rational((51+66)/2):0.111,Rational((76+66)/2):0.346,Rational((90+76)/2):0.486,Rational((90+100)/2):0.056,})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 558,
   "id": "69860be0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 76.743$"
      ],
      "text/plain": [
       "76.7430000000000"
      ]
     },
     "execution_count": 558,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 559,
   "id": "40a5f05b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Binomial(\"Y\",4,Rational(4,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "id": "d01a0460",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 1/625, 1: 16/625, 2: 96/625, 3: 256/625, 4: 256/625}"
      ]
     },
     "execution_count": 561,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(Y).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "id": "3d5b6bf6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{16}{5}$"
      ],
      "text/plain": [
       "16/5"
      ]
     },
     "execution_count": 562,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 565,
   "id": "229e4fd9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2.88735268984507$"
      ],
      "text/plain": [
       "2.88735268984507"
      ]
     },
     "execution_count": 565,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(49*sqrt(2)/24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "id": "1433edd0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2.85833333333333$"
      ],
      "text/plain": [
       "2.85833333333333"
      ]
     },
     "execution_count": 566,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(49*1.4/24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "id": "2e6bc801",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{9}{10}, \\frac{1}{9}\\right\\}$"
      ],
      "text/plain": [
       "{-9/10, 1/9}"
      ]
     },
     "execution_count": 573,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(Eq(sqrt(m**2+1)/(3*m**2+4),sqrt(10)/13),m**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 574,
   "id": "ff787d08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 729 m x^{6} - 1458 m x^{5} + 1215 m x^{4} - 540 m x^{3} + 135 m x^{2} - 18 m x + m + 1458 x^{7} - 2916 x^{6} + 2430 x^{5} - 1080 x^{4} + 270 x^{3} - 36 x^{2} + 2 x$"
      ],
      "text/plain": [
       "729*m*x**6 - 1458*m*x**5 + 1215*m*x**4 - 540*m*x**3 + 135*m*x**2 - 18*m*x + m + 1458*x**7 - 2916*x**6 + 2430*x**5 - 1080*x**4 + 270*x**3 - 36*x**2 + 2*x"
      ]
     },
     "execution_count": 574,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((2*x+m)*(3*x-1)**6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "id": "629e1e9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.function.UndefinedFunction"
      ]
     },
     "execution_count": 576,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 579,
   "id": "181f27ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "n=symbols(\"n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 581,
   "id": "1c69d52f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2}{5} - \\frac{16 \\left(- \\frac{1}{4}\\right)^{n}}{15}$"
      ],
      "text/plain": [
       "2/5 - 16*(-1/4)**n/15"
      ]
     },
     "execution_count": 581,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsolve(4*f(n+1)+f(n)-2,f(n),{f(1):Rational(2,3)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "id": "487da845",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle t$"
      ],
      "text/plain": [
       "t"
      ]
     },
     "execution_count": 582,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 583,
   "id": "2945aeeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{t \\left(t^{2} + 11\\right)}{\\left(t^{2} + 7\\right)^{2}}$"
      ],
      "text/plain": [
       "t*(t**2 + 11)/(t**2 + 7)**2"
      ]
     },
     "execution_count": 583,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=(t*(t**2+11)/(t**2+7)**2)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "id": "3b8597ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- t^{4} - 12 t^{2} + 77}{t^{6} + 21 t^{4} + 147 t^{2} + 343}$"
      ],
      "text/plain": [
       "(-t**4 - 12*t**2 + 77)/(t**6 + 21*t**4 + 147*t**2 + 343)"
      ]
     },
     "execution_count": 588,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(diff(expr,t))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 594,
   "id": "7de96ae1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(t^{2} + 7\\right)^{3}$"
      ],
      "text/plain": [
       "(t**2 + 7)**3"
      ]
     },
     "execution_count": 594,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(fraction(simplify(diff(expr,t)))[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 596,
   "id": "3b2e8402",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-6 + \\sqrt{113}, - \\sqrt{113} - 6\\right\\}$"
      ],
      "text/plain": [
       "{-6 + sqrt(113), -sqrt(113) - 6}"
      ]
     },
     "execution_count": 596,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(fraction(simplify(diff(expr,t)))[0],t**2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 599,
   "id": "ed54f86a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a + \\log{\\left(x \\right)}}{x}$"
      ],
      "text/plain": [
       "(a + log(x))/x"
      ]
     },
     "execution_count": 599,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=(ln(x)+a)/x\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 601,
   "id": "12082cec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a + \\log{\\left(x \\right)}}{x^{2}} + \\frac{1}{x^{2}}$"
      ],
      "text/plain": [
       "-(a + log(x))/x**2 + x**(-2)"
      ]
     },
     "execution_count": 601,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 600,
   "id": "2e524aec",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 a + 2 \\log{\\left(x \\right)} - 3}{x^{3}}$"
      ],
      "text/plain": [
       "(2*a + 2*log(x) - 3)/x**3"
      ]
     },
     "execution_count": 600,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 603,
   "id": "e96d9ae8",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAHWCAYAAAD+VRS3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAy/ElEQVR4nO3deXxU9b3/8ffMJDPZh0AgAWUVCypVNpfgXirSUiv9Wau36sVfkZYqKtVbi9rF5XKpP7W1tVfUarWt9xbvLdrrrbXFKou2iELjylIpQgIkhLDMhCwzk5nv749kJgkJIcucc2aS1/PxmMfMnDlz8snJecjb7/d8v1+XMcYIAAAAacvtdAEAAADoGwIdAABAmiPQAQAApDkCHQAAQJoj0AEAAKQ5Ah0AAECaI9ABAACkOQIdAABAmiPQHcUYo2AwKOZbBgAA6YJAd5Ta2lr5/X7V1tY6XQoAAEC3EOgAAADSHIEOAAAgzRHoAAAA0hyBDgAAIM0R6AAAANIcgQ4AACDNEegAAADSHIEOAAAgzRHoAAAA0hyBDgAAIM0R6AAAANIcgQ4AACDNEegAAADSHIEOAAAgzRHoAAAA0hyBDgAAIM0R6AAAANIcgQ4AACDNZThdAAD0lDFGTTGjaMwoEo0pGmt93xQzikaNmmLtt8davhNreR818e1qty0WfzbNPyexjzEt71tfx7fH9zVt3seMkdR8bCMlPjNq3dco/qz271u+2/YzqfXztuch8TqxrXXfZHPJ1f696+jP23521Ict+8eP0fy6zfaW/V1tDuSSK/EzXG1+Xny7q82BXWo9fvyzdsd1dTye29XmfbtjtLyP/4yjju92tfld2u7fss+xj9v6XSVeN3/udnc8nrvD79P62u12ddyWeN3y3OZ1/DN3y89ObDvqPLQet/VzdbKvy9XFMTqrqZPrAclFoAPQJWOMIlGjhnBUjU1RNUaiCjXF1BiJqjESf46qsSmmUMtnoaaYwi2PUFO05bllW7T5EWmKKRKNKRI1ie2RaExN0eaQFom1eR01aorGFIkHr1jywwoAax0dANUSMF1tw+3RgbblWW3CcPwY7UJldwKoWoNzu22uTgL0UceVOv6c+DG+cPpwXT75BCdOaTsEOqCfaYrGVBeKqjYU0ZFQk440Nqk21KTaxubXdaEm1YWbVB+Oqi501HO4SQ3hqOrDUTVEompoeU6XAJXhdsnjdiWemx9uedxShtstt1vyuFxyt+zjdjXv427Z5nGp9X3LZ65221r/w+9xu9q1frT/B6n5ffNxpbb/GLX9x0s6dqtSa+tT5y1VbVu62uyqths7axPpbUOJOeoS6HBFxFsVj9o/3lIYb23s7LO2T/HWy9b37Y+h+D5tjnV0S2fi6Kbzz9vVZEyb7W2O3a7FtJNjtG1tPfr7R3031skxY9343tHbY6Z9ffFjxEyb77Q5btufoTbfjx21X2LbUb9v2/2TwRgpmvgDpcd/U7rjlJJ8p0uQRKADUlZjJKpD9WEdrAvrUF1EB+vDOlwf1uH6iAINzY9gQ8fXdeGoZTW5XVJWpqf5keFWVqZHvkyPfBluZWW2vM9wy5sRf3bL63HLl+FOvM/0tGyPv/a0vs70uJTpcSvD7VJmhluZbrcyPC5lelzKSLx2y+N2JT5rG+Do1gGs0Rosjx8AjSQT67gt1nKA2NH7HxV8WwPqUeG07a0M5uhgHH/fvr5j/jwZxWLtf5/W0Nv+uLFOamx7Pk4bUeDAX6QjAh1go8ZIVPuCjaoKNGr/kZBqakOqORLWgbqQ9teGVXMkpJojIR2sC6u+j8HMl+FWflaG8nwZys/KVJ4vQ3kt73N9HuV6M5TjbX7d9jk706Nsr0c5Xk/idVZm8+tMD6EJGIjirc8t75wsBcdAoAOSJNQUVeXhRu053KA9hxq0+3CDqgINqgqGtC/QqKpgowINkR4dM8PtUmGuV4NzvCrMzVRhjleDcjJVkJWpguxM+Tt5FGQ3hzdvBoPYAWCgINABPXC4PqydB+q160Cddta0PB+o0+5DDdp/JNThPqPOZGW6VVKQpaH5PhXltXnke9u896ow16t8XwYtYgCA4+qXge6xxx7Tgw8+qMrKSp122ml65JFHdP755ztdFtJELGZUcaheH+87ou37j2h79RH9Y/8R7dhfd9wWtqxMt04YlK0TCnN0wqBsjfBnqdifpZKCLBUXND8XZBPSAADJ1e8C3fPPP6/Fixfrscce07nnnqsnnnhCn/vc57R582aNGjXK6fKQYhojUW2pDOqDPQF9tCeorftq9fG+2i7vXysu8Gn0kFyNGZKj0UNyNXpIjkYNbg5wg3O9hDUAgO1cxnSnkyh9nH322Zo6daqWL1+e2HbKKado7ty5WrZs2XG/HwwG5ff7FQgEVFCQGiNXkByNkai2VtXqgz0BfbD7sD7YE9Tf99V2OiWHN8Ot8UPzNH5Ynk6KPw/L1ejBucr2ehyoHgCAY+tXLXThcFibNm3SkiVL2m2fNWuW/vKXvygYDHb4TigUUigUSryvra2VpE73RXo5eCSkv1UcVln5If1t12FtqQyqqZPwNiQ3U6eMKNBpw/36VHG+xhfnafTgHGV4Og4qiDTWKdJoR/UAALTKz8/vsgeoXwW6mpoaRaNRFRcXt9teXFysvXv3yu/3d/tYI0eOTHZ5SFEVkt51uggAALpwvJ7DfhXo4o5OsMYYeTweBQKBDvse3UJXWVmps846S5s3b9YJJzi/lEc6CQaDGjlypCoqKmzprjbGaMf+I3pta7XWbtuvD/cGO3SfnjQ0V1NHF2rqqEGaMrJQJxRmp+w9bnafv/6Ec9c3nL++4fz1Hueu+/Lzu16Rol8FuqKiInk8HlVVVbXbXl1drZKSkh5dLPn5+VxcvVRQUGDZuWuKxrRp1yG9unmf/rxln3YeqG/9MDNbJxXl6tzxQ3TuSUU6Z9wQFeZ6LanDSlaev/6Oc9c3nL++4fz1Hueu7/pVoPN6vZo2bZpeffVVfelLX0psf/XVV3X55Zc7WBn6Ihoz+us/avS7sr16fes+HapvnTrE63FrxvghuuTUYl34qaE6sTDHwUoBAHBGvwp0knTbbbfpuuuu0/Tp01VaWqonn3xS5eXlWrhwodOloYd27D+ilX/brRf+tkeVgdaRCP7sTM2cOEyfPbVYF3xqqPJ8/e4yBgCgR/rdv4RXXXWVDhw4oPvuu0+VlZWaNGmS/vCHP2j06NHd+r7P52v3jO7z+Xz6wQ9+0KdzF2yM6OX3K/XbTbu1adehxPaCrAx9cfIIzfn0CJ05prDTEajpLhnnb6Di3PUN569vOH+9x7lLnn43D11fMQ+dM3YdqNPTb36i/964Ww2R5kl93S7pwk8N1ZenjdTMU4YpK5P53wAA6Ey/a6FDeikrP6Qn1+3QHz+qSqyDOn5Ynq6cdqK+NOUEDSvIcrZAAADSAIEOtovFjF7bWq0n1/1D7+xs7Va9aMJQff2CcSodNyRlpxYBACAVEehgq79sr9GyV7bowz3NK3FkelyaO/kE3XD+OE0o6XqOHQAA0DkCHWyxpTKoH76yVWv/vl+SlOfL0HWlo3X9jDEqplsVAIA+6X9DBY/jscce09ixY5WVlaVp06bpjTfe6HL/tWvXatq0acrKytK4ceP0+OOP21RpaurJ+VuzZo0yCoaqaM5izX5krdb+fb9MtEmXn+LX2m9fpO/Mnjhgwty6det02WWXacSIEXK5XPrd73533O9w7bXq6flbs2aNXC5Xh8fWrVvtKTiFLFu2TGeeeaby8/M1bNgwzZ07V9u2bTvu97j+enfuuPZaLV++XKeffnpi0uDS0lK98sorXX6H6673BlSge/7557V48WLdfffdKisr0/nnn6/Pfe5zKi8v73T/Tz75RJ///Od1/vnnq6ysTHfddZduueUWrVy50ubKU0NPzp8xRmsqIhpxw+PK+/QlcrncmnlyoX47/wz96NpSDckbWEPU6+rqdMYZZ+hnP/tZt/bn2muvp+cvbtu2baqsrEw8Tj75ZIsqTF1r167VTTfdpLfeekuvvvqqmpqaNGvWLNXV1R3zO1x/zXpz7uK49qQTTzxRP/zhD7Vx40Zt3LhRn/nMZ3T55Zfro48+6nR/rrs+MgPIWWedZRYuXNhu28SJE82SJUsS7wOBgJFkAoGAueOOO8zEiRPb7f+Nb3zDnHPOObbUm2q6c/6MMWZ/baOZ/+zbZvR3fm9Gf+f35vJH15q/7TpoZ6kpTZJ58cUXu9yHa+/YunP+Vq9ebSSZQ4cO2VJTOqmurjaSzNq1a4+5D9df57pz7rj2ulZYWGieeuqpTj/juuubAdNCFw6HtWnTJs2aNavd9lmzZumvf/1rp99Zv359h/0vvfRSbdy4UZFIpNPv9FfdPX+vb92n2Y+s05+3VCvDJR18/Sm9+/D1+vzZp2rmzJlavXq13aWnJa695JgyZYqGDx/OtddGIBCQJA0ePPiY+3D9da475y6Oa6+9aDSqFStWqK6uTqWlpZ3uw3XXNwMm0NXU1Cgajaq4uLjd9uLiYlVVVXX6naqqqk73b2pqUk1NjWW1pqLjnb+GcFTf/d0H+tqzG1VzJKwJxfl69Isj9fCCz+uFlb/VCy+8oAkTJmjmzJlat26dQ79F+uDa65vhw4frySef1MqVK7n22jDG6LbbbtN5552nSZMmHXM/rr+OunvuuPba++CDD5SXlyefz6eFCxfqxRdf1Kmnntrpvlx3fTPgRrkePb+ZMabLOc8627+z7QNFZ+fDFI7UnEff0I79zfeVzD9vrL596YTmlR1KT0/sW1paqoqKCj300EO64IILbK07HXHt9d6ECRM0YcKExHuuvWaLFi3S+++/rzfffPO4+3L9tdfdc8e1196ECRP07rvv6vDhw1q5cqXmzZuntWvXHjPUcd313oBpoSsqKpLH4+nQGlddXd3h/wjiSkpKOt0/IyNDQ4YMsazWVNTZ+YvGjN48mKvwBbdox/46FRf49Nz8s/W9L5x6zGW6zjnnHH388cd2lZ22uPaSb6BfezfffLNeeuklrV69WieeeGKX+3L9tdeTc9eZgXzteb1ejR8/XtOnT9eyZct0xhln6Cc/+Umn+3Ld9c2ACXRer1fTpk3Tq6++2m77q6++qhkzZnT6ndLS0g77r1q1StOnT1dmZqZltaaio8/fnsMNuvrJ9dqSebLk9ujzny7RnxZfoPNOLuryOGVlZRo+fLgdJac1rr3kG6jXnjFGixYt0gsvvKDXX39dY8eOPe53uP6a9ebcdWagXnudMcYoFAp1+hnXXR85NBjDEStWrDCZmZnm6aefNps3bzaLFy82ubm5ZufOncYYY5YsWWKuuuqqxCjXHTt2mJycHPOtb33LbN682Tz99NMmMzPT/Pa3v3X4N3FG/Pw9uPxZM+3eV8zo7/zejPzWf5nH/1RmYrGYWbJkibnuuusS+//4xz82L774ovn73/9uPvzwQ7NkyRIjyaxcudLB38IZtbW1pqyszJSVlRlJ5kc/+pEpKyszu3btMsaYDueOa6+9np4/rr1W3/zmN43f7zdr1qwxlZWViUd9fX1iH66/zvXm3HHttbrzzjvNunXrzCeffGLef/99c9dddxm3221WrVpljOG6S7YBFeiMMebf//3fzejRo43X6zVTp05tN/x83rx55txzz00EOmOMWbNmjZkyZYrxer1mzJgxZvny5U6VnhLuf+QJM/rm58zo7/zejLvpF+a/X1md+GzevHnmwgsvTLx/4IEHzEknnWSysrJMYWGhOe+888zLL79sf9EpID6VwdGPefPmGWM6njtjuPba6un549pr1dl5k2SeeeaZxD5cf53rzbnj2mv1ta99LfHv7dChQ83MmTMTYc4YrrtkcxnTcschJEnBYFB+v1+BQEAFBQVOl5NStlcf0Vd//paqa0P6VHGe/uOGczQ0f2BNEAwAQCoacKNc0Tsf76vVP/18g2qOhDSxJF//ccPZA261BwAAUhWBDse1rapW1zz1lmqOhHXK8AL9xw1na3Cu1+myAABACwIdurSlMqhrntqgg3VhnTaiQM/NP1uFhDkAAFIKgQ7H9NHegK59aoMO1Uf06RP8+vX8szQohzAHAECqIdChUx/uCejapzfocH1EZ5zo16/mny1/NvMAAQCQigh06OCD3QFd89RbCjY2afLIQfrV/LNUkEWYAwAgVQ2YlSLQPftrQ/q/z76tYGOTpo4apF8T5gAASHm00CHBGKMlK99XzZGwJhTn61fzz1aej0sEAIBURwsdEn7zdoVe21otr8etn/zTZMIcAABpgkAHSdKO/Ud0/+83S5LumD1BE0tYJQMAgHRBoIMi0Zi+9fy7aohENeOkIfrauWOdLgkAAPQAgQ569PXtem93QAVZGXr4K2fI7XY5XRKQ8vbv36+SkhL927/9W2Lbhg0b5PV6tWrVKgcrAzAQcZPUALdp1yH97PWPJUlLv/RpDfdnO1wRkB6GDh2qX/ziF5o7d65mzZqliRMn6tprr9WNN96oWbNmOV0egAHGZYwxTheRSoLBoPx+vwKBgAoK+vd9ZEdCTZrz0ze060C95k4eoUeunuJ0SUDauemmm/TnP/9ZZ555pt577z298847ysrKcrosAAMMge4oAynQfee37+v5jRU6YVC2/nDr+awEAfRCQ0ODJk2apIqKCm3cuFGnn3660yUBGIC4h26A+tNHVXp+Y4VcLunhr5xBmAN6aceOHdq7d69isZh27drldDkABijuoRuAqoONWrLyfUnS1y8Yp3PGDXG4IiA9hcNhXXPNNbrqqqs0ceJEzZ8/Xx988IGKi4udLg3AAEML3QBjjNEdK9/XofqITh1eoNsu+ZTTJQFp6+6771YgENBPf/pT3XHHHTrllFM0f/58p8sCMAAR6AaY597apTXb9suX4dZPrp4sX4bH6ZKAtLRmzRo98sgj+vWvf62CggK53W79+te/1ptvvqnly5c7XR6AAYYu1wEk2BjR//vTNknSks9N1MnF+Q5XBKSviy66SJFIpN22UaNG6fDhw84UBGBAo4VuAPnPDeWqbWzS+GF5mlc6xulyAABAkhDoBohQU1S/ePMTSdI3LhjHahAAAPQjBLoB4sW/7VF1bUjD/Vm6fPIJTpcDAACSiEA3AERjRk+u2yFJmn/eWHkz+LMDANCf8C/7ALDqoyrtqKmTPztTV581yulyAABAkhHo+jljjB5f+w9J0j+Xjlaej4HNAAD0NwS6fm79jgN6b3dAvgy35s0Y43Q5AADAAgS6fu7xtc33zn1l+kgV5fkcrgYAAFiBQNePfbQ3oHV/3y+3S1pw/jinywEAABYh0PVj8da5OaeP0KghOQ5XAwAArEKg66fKD9Tr5ff3SpIWXkjrHAAA/RmBrp/6+Rs7FDPSBZ8aqtNG+J0uBwAAWIhA1w/VHAnpvzZWSKJ1DgCAgYBA1w/98q87FWqK6YwT/SodN8TpcgAAgMUIdP3MkVCTfvnXnZKkhReeJJfL5WxBAADAcgS6fmbF2+UKNjZpbFGuZp1W4nQ5AADABgS6fiTcFNNTb3wiSfr6BePkcdM6BwDAQECg60f+5909qgo2ali+T/9n6glOlwMAAGxCoOtHnttQLkn6v+eOlS/D43A1AADALgS6fqK6tlHvVRyWJF1B6xwAAAMKga6fWL21WpJ0+ol+DSvIcrgaAABgJwJdP/HaluZAN3NiscOVAAAAuxHo+oHGSFRvfFwjSZp5yjCHqwEAAHYj0PUD63ccUEMkquICn04bUeB0OQAAwGYEun7g9Zbu1s9MLGZlCAAABiACXZozxui1LfskSZ+luxUAgAGJQJfmtlbVam+gUb4Mt2acVOR0OQAAwAEEujQXb507b3yRsr1MJgwAwEBEoEtzr7XMP/cZulsBABiwCHRprOZISO+2rA7B/HMAAAxcBLo0tnprtYyRJp1QoBI/q0MAADBQEejS2GttpisBAAADF4EuTYWaonrj4/2SmK4EAICBjkCXpjbsOKi6cFRD832aNMLvdDkAAMBBBLo09XrL6NaZE4fJ7WZ1CAAABjICXRoyxujPLfPPfWYi3a0AAAx0BLo09HH1Ee0+1CBvhlvnnczqEAAADHQEujQUb52bcdIQ5XgzHK4GAAA4jUCXhl5vma5k5ilMVwIAAAh0aedgXVh/Kz8kqXlABAAAAIEuzazZVq2YkU4ZXqARg7KdLgcAAKQAAl2aia8OwWTCAAAgjkCXRsJNMa37e/PqEExXAgAA4gh0aeSdnQdVG2pSUZ5XZ5w4yOlyAABAiiDQpZE125q7Wy+ewOoQAACgFYEujby/OyBJOnvcEIcrAQAAqYRAlyaMMdpSGZQknTq8wOFqAABAKiHQpYk9hxsUbGxSpsel8cPynC4HAACkEAJdmti8t7l17uRh+fJm8GcDAACtSAZpYktlraTmCYUBAADaItClic2VzQMiTh1BoAMAAO0R6NJEawtdvsOVAACAVEOgSwO1jRGVH6yXxAhXAADQEYEuDWytam6dG+HP0qAcr8PVAACAVNOvAt2YMWPkcrnaPZYsWeJ0WX0WH+HK/XMAAKAzGU4XkGz33XefFixYkHifl5f+c7bFAx0jXAEAQGf6XaDLz89XSUmJ02Uk1ZYqVogAAADH1q+6XCXpgQce0JAhQzR58mQtXbpU4XC4y/1DoZCCwWC7RyppisYS99DR5QoAADrTr1robr31Vk2dOlWFhYV6++23deedd+qTTz7RU089dczvLFu2TPfee6+NVfbMJzV1CjfFlOv1aGRhjtPlAACAFOQyxhini+jKPffcc9zA9c4772j69Okdtq9cuVJf/vKXVVNToyFDhnT63VAopFAolHgfDAY1cuRIBQIBFRQ43yL2P+/u0a0r3tX00YX67TdnOF0OAABIQSnfQrdo0SJdffXVXe4zZsyYTrefc845kqTt27cfM9D5fD75fL4+1WglBkQAAIDjSflAV1RUpKKiol59t6ysTJI0fPjwZJZkq82VTFkCAAC6lvKBrrvWr1+vt956SxdffLH8fr/eeecdfetb39IXv/hFjRo1yunyem1LJS10AACga/0m0Pl8Pj3//PO69957FQqFNHr0aC1YsEB33HGH06X1WnVto2qOhOV2SROKWcMVAAB0rt8EuqlTp+qtt95yuoykit8/N7YoV9lej8PVAACAVNXv5qHrT7ZUxuef8ztcCQAASGUEuhSWGBDB/XMAAKALBLoUtnlvQJJ0ynDunwMAAMdGoEtRDeGoPqmpk8SUJQAAoGsEuhS1bV+tYkYqyvNqWH6W0+UAAIAURqBLUcw/BwAAuotAl6LiU5YwIAIAABwPgS5FbWHJLwAA0E0EuhQUi5nWQEcLHQAAOA4CXQoqP1ivunBU3gy3xhblOl0OAABIcQS6FBRvnZtYkq8MD38iAADQNdJCCoqvEHFKCd2tAADg+Ah0KYgBEQAAoCcIdCkoPmUJc9ABAIDuINClmMP1Ye0NNEqSJrKGKwAA6AYCXYqJ3z83cnC2CrIyHa4GAACkAwJdimGFCAAA0FMEuhSzpbJWknTqcL/DlQAAgHRBoEsxiSlLuH8OAAB0E4EuhRhj9EnNEUnSp4oJdAAAoHsIdCkk2NikxkhMklTiz3K4GgAAkC4IdCmkOtg8XYk/O1NZmR6HqwEAAOmCQJdCqloCXXGBz+FKAABAOiHQpZB9wZAkqbiA7lYAANB9BLoUsi/RQkegAwAA3UegSyH76HIFAAC9QKBLIfFAV0ILHQAA6AECXQqJ30M3jEAHAAB6gECXQriHDgAA9AaBLkXEYkbVtc0tdHS5AgCAniDQpYgDdWFFY0Yul1SU53W6HAAAkEYIdCki3t1alOdThoc/CwAA6D6SQ4pghCsAAOgtAl2KaF0lgjnoAABAzxDoUkR8HVemLAEAAD1FoEsR1XS5AgCAXiLQpQiW/QIAAL1FoEsRrBIBAAB6i0CXIhjlCgAAeotAlwLCTTEdqAtLYtkvAADQcwS6FLD/SHN3q9fjVmFOpsPVAACAdEOgSwFVgfiUJT65XC6HqwEAAOmGQJcCqhMjXOluBQAAPUegSwFMWQIAAPqCQJcCqhLLftFCBwAAeo5AlwLocgUAAH1BoEsB+2rpcgUAAL1HoEsB8VGutNABAIDeINClgGruoQMAAH1AoHNYXahJtaEmSQQ6AADQOwQ6h8WnLMnzZSjPl+FwNQAAIB0R6By2r6W7dRgDIgAAQC8R6BxWHR/hmk93KwAA6B0CncPiI1xL/AQ6AADQOwQ6h9HlCgAA+opA57B9dLkCAIA+ItA5bB+TCgMAgD4i0Dks3kJX4qfLFQAA9A6BzkHGmNZ76OhyBQAAvUSgc9Dh+ojCTTFJDIoAAAC9R6BzULy7dXCuV74Mj8PVAACAdEWgc1BrdyutcwAAoPcIdA5ihCsAAEgGAp2D9gVbRrgS6AAAQB8Q6ByUmFSYAREAAKAPCHQOqgrEl/2ihQ4AAPQegc5B1bV0uQIAgL4j0Dkofg8dgyIAAEBfEOgc0hSNaX9tc5cr99ABAIC+INA55EBdWDEjedwuDckj0AEAgN4j0Dkk3t06NM8nj9vlcDUAACCdEegcUhVgyhIAAJAcBDqH7EvcP8eACAAA0DcEOodUM8IVAAAkCYHOIXS5AgCAZCHQOYQuVwAAkCwEOofQ5QoAAJKFQOeQKgIdAABIEgKdAxojUR2uj0hiHVcAANB3GT39wrZt2/Sb3/xGb7zxhnbu3Kn6+noNHTpUU6ZM0aWXXqorrrhCPh83+nclvuSXL8Otguwe/wkAAADa6XYLXVlZmS655BKdccYZWrdunc4880wtXrxY999/v6699loZY3T33XdrxIgReuCBBxQKhaysO6217W51uVglAgAA9E23m4fmzp2rb3/723r++ec1ePDgY+63fv16/fjHP9bDDz+su+66KylF9jfxZb/obgUAAMnQ7UD38ccfy+v1Hne/0tJSlZaWKhwO96mw/mxfsLn1chhz0AEAgCTodpdrd8KcJNXX1/do/4FoHyNcAQBAEvVqlOtFF12k3bt3d9i+YcMGTZ48ua819Xt0uQIAgGTqVaArKCjQ6aefrhUrVkiSYrGY7rnnHl1wwQX64he/mNQC+6N4oKPLFQAAJEOv5sx46aWX9Pjjj+uGG27QSy+9pJ07d6q8vFwvv/yyPvvZzya7xn4nfg8dXa4AACAZej0J2sKFC7Vr1y498MADysjI0Jo1azRjxoxk1tYvGWPocgUAAEnVqy7XQ4cO6YorrtDy5cv1xBNP6Ctf+YpmzZqlxx57LNn19TtHQk2qD0cl0eUKAACSo1eBbtKkSdq3b5/Kysq0YMECPffcc3r66af1ve99T3PmzEl2jZKkpUuXasaMGcrJydGgQYM63ae8vFyXXXaZcnNzVVRUpFtuuSXlpk+Jt87lZ2Uox8sqEQAAoO96FegWLlyodevWaezYsYltV111ld577z3LAlQ4HNaVV16pb37zm51+Ho1GNWfOHNXV1enNN9/UihUrtHLlSt1+++2W1NNb8fvn6G4FAADJ4jLGGKeL6Ilnn31Wixcv1uHDh9ttf+WVV/SFL3xBFRUVGjFihCRpxYoVuv7661VdXa2CgoJuHT8YDMrv9ysQCHT7Oz3xwt9267b/ek/njS/SczecnfTjAwCAgafbLXTl5eU9OvCePXt6XExfrF+/XpMmTUqEOUm69NJLFQqFtGnTpmN+LxQKKRgMtntYqYopSwAAQJJ1O9CdeeaZWrBggd5+++1j7hMIBPTzn/9ckyZN0gsvvJCUArurqqpKxcXF7bYVFhbK6/WqqqrqmN9btmyZ/H5/4jFy5EhL66ymyxUAACRZtwPdli1b5Pf7NXv2bBUXF2vOnDlasGCBbr75Zl177bWaOnWqhg0bpmeffVYPPvigbr755uMe85577pHL5erysXHjxm7/Mi6Xq8M2Y0yn2+PuvPNOBQKBxKOioqLbP683WPYLAAAkW7eHWe7evVsPPPCA/vVf/1WvvPKK1q1bp507d6qhoUFFRUW65pprdOmll2rSpEnd/uGLFi3S1Vdf3eU+Y8aM6daxSkpKtGHDhnbbDh06pEgk0qHlri2fzyefz77uz9ZAR5crAABIjm4HuilTpqiqqkpDhw7V7bffrnfeeUdDhgzp0w8vKipSUVFRn44RV1paqqVLl6qyslLDhw+XJK1atUo+n0/Tpk1Lys9Ihura5i7Xofm00AEAgOTodqAbNGiQduzYoaFDh2rnzp2KxWJW1tVBeXm5Dh48qPLyckWjUb377ruSpPHjxysvL0+zZs3Sqaeequuuu04PPvigDh48qH/5l3/RggULLBmt2ltHQk2SJH82c9ABAIDk6HaquOKKK3ThhRdq+PDhcrlcmj59ujweT6f77tixI2kFxn3/+9/XL3/5y8T7KVOmSJJWr16tiy66SB6PRy+//LJuvPFGnXvuucrOztZXv/pVPfTQQ0mvpS/qQ82rRGQzqTAAAEiSHs1D98c//lHbt2/XLbfcovvuu0/5+fmd7nfrrbcmrUC7WTkPXVM0pvF3vyJJKvveJSrM9Sb1+AAAYGDqUTPR7NmzJUmbNm3SrbfeesxAh87VR6KJ1zm+zls3AQAAeqpX/X7PPPNMsusYEBrCzYHO43bJ6+nVqmsAAAAdkCpsVN8S6HIyPV3OjQcAANATBDob1bWMcM320t0KAACSh0Bno4aWe+hyCHQAACCJCHQ2SnS5MmUJAABIIgKdjRrCzV2utNABAIBkItDZqC4xqTCBDgAAJA+Bzkb13EMHAAAsQKCzUbzLNZd76AAAQBIR6GwUHxRBlysAAEgmAp2NGsJ0uQIAgOQj0NmoLhyfWJguVwAAkDwEOhvV00IHAAAsQKCzUbzLNZdABwAAkohAZ6PWQRF0uQIAgOQh0NmonpUiAACABQh0NmLaEgAAYAUCnY1a76GjyxUAACQPgc5GjHIFAABWINDZqHUeOgIdAABIHgKdjVgpAgAAWIFAZ5NwU0xNMSNJysnkHjoAAJA8BDqbxFvnJLpcAQBAchHobFIfab5/LtPjkjeD0w4AAJKHZGGTulDLHHSZtM4BAIDkItDZpHVABPfPAQCA5CLQ2SSx7JePFjoAAJBcBDqb1EeYsgQAAFiDQGeT+pZ76JiyBAAAJBuBzib1rBIBAAAsQqCzSQNdrgAAwCIEOpvUM8oVAABYhEBnk3rWcQUAABYh0NmkPtQybQmBDgAAJBmBzibxaUsYFAEAAJKNQGeT+EoRudxDBwAAkoxAZxOmLQEAAFYh0NmEQREAAMAqBDqbEOgAAIBVCHQ2iQe6bO6hAwAASUags0lDyz10ubTQAQCAJCPQ2aS1hY5ABwAAkotAZxOW/gIAAFYh0NnAGJOYtoRBEQAAINkIdDYINcUUM82vCXQAACDZCHQ2iK8SIdHlCgAAko9AZ4O6lu5Wb4ZbHrfL4WoAAEB/Q6CzQQOTCgMAAAsR6GyQGOGaSaADAADJR6CzQSLQ+bh/DgAAJB+BzgYNEaYsAQAA1iHQ2aAu1LJKBF2uAADAAgQ6GzAoAgAAWIlAZ4PEKhHcQwcAACxAoLNBfYRRrgAAwDoEOhvUh+hyBQAA1iHQ2SA+bUk2y34BAAALEOhswLQlAADASgQ6G9QzyhUAAFiIQGeDusQ9dHS5AgCA5CPQ2YAuVwAAYCUCnQ1aB0UQ6AAAQPIR6GwQXykily5XAABgAQKdDWihAwAAViLQ2SCx9BeBDgAAWIBAZwOmLQEAAFYi0FnMGKOGCF2uAADAOgQ6izVGYjKm+TWDIgAAgBUIdBara7l/TpKyM2mhAwAAyUegs1h8ypKsTLfcbpfD1QAAgP6IQGex1gERdLcCAABrEOgsxpQlAADAagQ6izUwZQkAALAYgc5idYlVIuhyBQAA1iDQWSzR5coIVwAAYBECncXocgUAAFYj0FksMcrVR5crAACwBoHOYnS5AgAAqxHoLFYfZh1XAABgLQKdxeq5hw4AAFiMQGex+KCIXO6hAwAAFiHQWaw+0tLlyj10AADAIgQ6i9WHWPoLAABYi0BnMQZFAAAAqxHoLBbvcs1h6S8AAGARAp3FGlrmoculhQ4AAFiEQGexuhBdrgAAwFoEOos10OUKAAAsljaBbunSpZoxY4ZycnI0aNCgTvdxuVwdHo8//ri9hR4lsfQXLXQAAMAiadNsFA6HdeWVV6q0tFRPP/30Mfd75plnNHv27MR7v99vR3mdisWMGiMxSQQ6AABgnbQJdPfee68k6dlnn+1yv0GDBqmkpMSGio4v3t0q0eUKAACskzZdrt21aNEiFRUV6cwzz9Tjjz+uWCzW5f6hUEjBYLDdI1nqWrpbXS4pK7PfnWoAAJAi+lWz0f3336+ZM2cqOztbr732mm6//XbV1NTou9/97jG/s2zZskTrX7LF13HNzvTI5XJZ8jMAAAAcbTa65557Oh3I0PaxcePGbh/vu9/9rkpLSzV58mTdfvvtuu+++/Tggw92+Z0777xTgUAg8aioqOjrr5UQXyWC7lYAAGAlR5PGokWLdPXVV3e5z5gxY3p9/HPOOUfBYFD79u1TcXFxp/v4fD75fL5e/4yutAY6BkQAAADrOBroioqKVFRUZNnxy8rKlJWVdcxpTqzGlCUAAMAOadMXWF5eroMHD6q8vFzRaFTvvvuuJGn8+PHKy8vT//7v/6qqqkqlpaXKzs7W6tWrdffdd+vrX/+6ZS1wxxNvoWOVCAAAYKW0CXTf//739ctf/jLxfsqUKZKk1atX66KLLlJmZqYee+wx3XbbbYrFYho3bpzuu+8+3XTTTU6VnBgUQQsdAACwkssYY5wuIpUEg0H5/X4FAgEVFBT06Vj/uaFcd734gS45tVg//+fpSaoQAACgPSZHsxD30AEAADsQ6CzEKFcAAGAHAp2FEoMiMtPmVkUAAJCGCHQWamjpcs310UIHAACsQ6CzENOWAAAAOxDoLJS4hy6TQAcAAKxDoLNQ6yhX7qEDAADWIdBZiC5XAABgBwKdhRoizYGOQREAAMBKBDoL1YWau1yZtgQAAFiJQGch1nIFAAB2INBZqD5CoAMAANYj0FkoMW2Jjy5XAABgHQKdRZqiMYWbYpKYhw4AAFiLQGeReHerxLQlAADAWgQ6i8QHRLhdki+D0wwAAKxD0rBI4v45b4ZcLpfD1QAAgP6MQGeR1mW/6G4FAADWItBZpJ456AAAgE0IdBZpXceVKUsAAIC1CHQWaaDLFQAA2IRAZxG6XAEAgF0IdBYh0AEAALsQ6CzSOsqVe+gAAIC1CHQWaR0UQQsdAACwFoHOIvGVIljHFQAAWI1AZ5HEPXQ+ulwBAIC1CHQWqWPaEgAAYBMCnUUaGOUKAABsQqCzSGJQBPfQAQAAixHoLBJvocvlHjoAAGAxAp1F6iPN99AxbQkAALAagc4i9SGmLQEAAPYg0FmkdekvulwBAIC1CHQWiS/9RZcrAACwGoHOIg2R+KAIAh0AALAWgc4C4aaYIlEjScrJpMsVAABYi0BngfiUJRJdrgAAwHoEOgvEpyzJcLvkzeAUAwAAa5E2LFDPsl8AAMBGBDoLJOagY8oSAABgAwKdBeJTltBCBwAA7ECgs0B9y5QlDIgAAAB2INBZoIF76AAAgI0IdBZg2S8AAGAnAp0FuIcOAADYiUBngXgLHffQAQAAOxDoLMA8dAAAwE4EOgs0tHS55nIPHQAAsAGBzgJ1dLkCAAAbEegswLQlAADATgQ6C8RHuWbT5QoAAGxAoLNAYlBEJi10AADAegQ6C8S7XHN9BDoAAGA9Ap0FWgdF0OUKAACsR6CzQAMrRQAAABsR6CyQWCmCe+gAAIANCHQWaL2Hji5XAABgPQJdkhljVEeXKwAAsBGBLslCTTHFTPNrVooAAAB2INAlWby7VWIeOgAAYA8CXZLVR5oDndfjVoaH0wsAAKxH4kiyxJQlTCoMAABsQqBLsroQy34BAAB7EeiSLDEHHQMiAACATQh0SdYQiU9Zwhx0AADAHgS6JIu30DEHHQAAsAuBLsnqQwQ6AABgLwJdktWH6XIFAAD2ItAlWXweOgZFAAAAuxDokqyBe+gAAIDNCHRJ1joogi5XAABgDwJdkrXeQ0cLHQAAsAeBLsmYtgQAANiNQJdkrBQBAADsRqBLsvigiFzuoQMAADYh0CVZXcs9dLTQAQAAuxDokoxpSwAAgN0IdEnGoAgAAGA3Al2SJQZFZHIPHQAAsAeBLsni89Dl+mihAwAA9iDQJZExRg2s5QoAAGxGoEuixkhMxjS/ZukvAABgFwJdEsW7WyUpO5MWOgAAYA8CXRLFB0RkZbrlcbscrgYAAAwUBLokap2yhO5WAABgHwJdEsW7XOluBQAAdiLQJRGrRAAAACcQ6JIo0eXqo8sVAADYJy0C3c6dOzV//nyNHTtW2dnZOumkk/SDH/xA4XC43X7l5eW67LLLlJubq6KiIt1yyy0d9rFSXUuXaw5drgAAwEZp0ZS0detWxWIxPfHEExo/frw+/PBDLViwQHV1dXrooYckSdFoVHPmzNHQoUP15ptv6sCBA5o3b56MMXr00UdtqZMuVwAA4IS0CHSzZ8/W7NmzE+/HjRunbdu2afny5YlAt2rVKm3evFkVFRUaMWKEJOnhhx/W9ddfr6VLl6qgoMDyOhPruBLoAACAjdKiy7UzgUBAgwcPTrxfv369Jk2alAhzknTppZcqFApp06ZNxzxOKBRSMBhs9+it+LJftNABAAA7pWWg+8c//qFHH31UCxcuTGyrqqpScXFxu/0KCwvl9XpVVVV1zGMtW7ZMfr8/8Rg5cmSv6zptRIGuO2e0Sk8a0utjAAAA9JSjge6ee+6Ry+Xq8rFx48Z239m7d69mz56tK6+8UjfccEO7z1yujqszGGM63R535513KhAIJB4VFRW9/n0umjBM98+dpC9NObHXxwAAAOgpR++hW7Roka6++uou9xkzZkzi9d69e3XxxRertLRUTz75ZLv9SkpKtGHDhnbbDh06pEgk0qHlri2fzyefz9fz4gEAAFKEo4GuqKhIRUVF3dp3z549uvjiizVt2jQ988wzcrvbNy6WlpZq6dKlqqys1PDhwyU1D5Tw+XyaNm1a0msHAABIFS5jjHG6iOPZu3evLrzwQo0aNUq/+tWv5PG0DjooKSmR1DxtyeTJk1VcXKwHH3xQBw8e1PXXX6+5c+f2aNqSYDAov9+vQCBgy8hYAACAvkqLaUtWrVql7du3a/v27TrxxPb3p8XzqMfj0csvv6wbb7xR5557rrKzs/XVr341Ma0JAABAf5UWLXR2ooUOAACkm7SctgQAAACtCHQAAABpjkAHAACQ5gh0AAAAaY5ABwAAkOYIdAAAAGmOQAcAAJDmCHQAAABpjkAHAACQ5gh0AAAAaY5ABwAAkOYIdAAAAGmOQAcAAJDmCHQAAABpzmWMMU4XkUqMMaqtrVV+fr5cLpfT5QAAABwXgQ4AACDN0eUKAACQ5gh0AAAAaY5ABwAAkOYIdAAAAGmOQAcAAJDmCHQAAABpjkAHAACQ5v4/V3F/Jwj85yYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7f4f4504a0a0>"
      ]
     },
     "execution_count": 603,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr.subs(a,1-ln(2)),(x,0.1,2*exp(1/2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 605,
   "id": "6023bd5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{e^{x}}{2} + \\frac{\\log{\\left(x \\right)} - \\log{\\left(2 \\right)} + 1}{x^{2}} - \\frac{1}{x^{2}}$"
      ],
      "text/plain": [
       "exp(x)/2 + (log(x) - log(2) + 1)/x**2 - 1/x**2"
      ]
     },
     "execution_count": 605,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(exp(x)/2-expr.subs(a,1-ln(2)),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 610,
   "id": "2ef094cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2} e^{x}}{2} + \\log{\\left(x \\right)} - \\log{\\left(2 \\right)}$"
      ],
      "text/plain": [
       "x**2*exp(x)/2 + log(x) - log(2)"
      ]
     },
     "execution_count": 610,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "together(diff(exp(x)/2-expr.subs(a,1-ln(2)),x)).args[2]/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 613,
   "id": "266a136f",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7f4f65c05640>"
      ]
     },
     "execution_count": 613,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(together(diff(exp(x)/2-expr.subs(a,1-ln(2)),x)).args[2]/2,(x,0.1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 611,
   "id": "313a4142",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2} e^{x}}{2} + x e^{x} + \\frac{1}{x}$"
      ],
      "text/plain": [
       "x**2*exp(x)/2 + x*exp(x) + 1/x"
      ]
     },
     "execution_count": 611,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(together(diff(exp(x)/2-expr.subs(a,1-ln(2)),x)).args[2]/2,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 618,
   "id": "5b771dde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sympy.core.symbol.Symbol"
      ]
     },
     "execution_count": 618,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 624,
   "id": "ef80ec91",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "did not evaluate to a bool: None",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [624]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m linsolve([\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39mx\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m3\u001b[39m\u001b[38;5;241m*\u001b[39my\u001b[38;5;241m<\u001b[39m\u001b[38;5;241m10\u001b[39m,\u001b[43mx\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mNaturals\u001b[49m,y \u001b[38;5;129;01min\u001b[39;00m Naturals],[x,y])\n",
      "File \u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/sets/sets.py:702\u001b[0m, in \u001b[0;36mSet.__contains__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m    698\u001b[0m b \u001b[38;5;241m=\u001b[39m tfn[c]\n\u001b[1;32m    699\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m b \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    700\u001b[0m     \u001b[38;5;66;03m# x in y must evaluate to T or F; to entertain a None\u001b[39;00m\n\u001b[1;32m    701\u001b[0m     \u001b[38;5;66;03m# result with Set use y.contains(x)\u001b[39;00m\n\u001b[0;32m--> 702\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdid not evaluate to a bool: \u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m'\u001b[39m \u001b[38;5;241m%\u001b[39m c)\n\u001b[1;32m    703\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m b\n",
      "\u001b[0;31mTypeError\u001b[0m: did not evaluate to a bool: None"
     ]
    }
   ],
   "source": [
    "linsolve([2*x+3*y<10,x in Naturals,y in Naturals],[x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 627,
   "id": "869a5f7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 627,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.5 in Naturals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 629,
   "id": "1d0880ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 \\cos^{3}{\\left(x \\right)} - 3 \\cos{\\left(x \\right)}$"
      ],
      "text/plain": [
       "4*cos(x)**3 - 3*cos(x)"
      ]
     },
     "execution_count": 629,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(cos(3*x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 630,
   "id": "502377f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 \\sin^{3}{\\left(x \\right)} + 3 \\sin{\\left(x \\right)}$"
      ],
      "text/plain": [
       "-4*sin(x)**3 + 3*sin(x)"
      ]
     },
     "execution_count": 630,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(sin(3*x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 633,
   "id": "8a5067d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\sin{\\left(\\frac{\\pi}{18} \\right)}, - \\sin{\\left(\\frac{5 \\pi}{18} \\right)}, \\cos{\\left(\\frac{\\pi}{9} \\right)}\\right\\}$"
      ],
      "text/plain": [
       "{-sin(pi/18), -sin(5*pi/18), cos(pi/9)}"
      ]
     },
     "execution_count": 633,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(solveset(8*x**3-6*x-1,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 634,
   "id": "1518de71",
   "metadata": {},
   "outputs": [],
   "source": [
    "x1=-sin(5*pi/18)\n",
    "x2=-sin(pi/18)\n",
    "x3=cos(pi/9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 637,
   "id": "35c2899b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -9.0 \\cdot 10^{-125}$"
      ],
      "text/plain": [
       "-0.e-124"
      ]
     },
     "execution_count": 637,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N((x1**2-x3**2)-Rational(1,2)*(x1-x2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 638,
   "id": "4d5b3aae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{8} - 4 x^{7} + 28 x^{5} - 70 x^{4} + 84 x^{3} - 56 x^{2} + 20 x - 3$"
      ],
      "text/plain": [
       "x**8 - 4*x**7 + 28*x**5 - 70*x**4 + 84*x**3 - 56*x**2 + 20*x - 3"
      ]
     },
     "execution_count": 638,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((x+3)*(x-1)**7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 642,
   "id": "4f9995d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3}{4} - \\frac{2^{- m} m}{4} - \\frac{3 \\cdot 2^{- m}}{4}$"
      ],
      "text/plain": [
       "3/4 - m/(4*2**m) - 3/(4*2**m)"
      ]
     },
     "execution_count": 642,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(simplify(summation((n+1)/2**(n+2),(n,1,m))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 643,
   "id": "326390f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{\\sqrt{11}}{4} + \\frac{\\sqrt{3}}{4}, \\frac{\\sqrt{3}}{4} + \\frac{\\sqrt{11}}{4}\\right\\}$"
      ],
      "text/plain": [
       "{-sqrt(11)/4 + sqrt(3)/4, sqrt(3)/4 + sqrt(11)/4}"
      ]
     },
     "execution_count": 643,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(2*x**2-sqrt(3)*x-1,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 645,
   "id": "93e3df51",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Hypergeometric(\"X\",20,5,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 646,
   "id": "cb9f1962",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 21/38, 1: 15/38, 2: 1/19}"
      ]
     },
     "execution_count": 646,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(X).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 647,
   "id": "6b3aa182",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "execution_count": 647,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 648,
   "id": "6aecb142",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 192 x^{\\frac{9}{2}} - 160 x^{\\frac{3}{2}} + 64 x^{6} + 240 x^{3} + 60 + \\frac{1}{x^{3}} - \\frac{12}{x^{\\frac{3}{2}}}$"
      ],
      "text/plain": [
       "-192*x**(9/2) - 160*x**(3/2) + 64*x**6 + 240*x**3 + 60 + x**(-3) - 12/x**(3/2)"
      ]
     },
     "execution_count": 648,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((2*x-1/sqrt(x))**6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ea1e53d",
   "metadata": {},
   "source": [
    "$\\chi$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 650,
   "id": "18f97087",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{n^{3}}{3} - n^{2} - \\frac{2 n}{3}$"
      ],
      "text/plain": [
       "-n**3/3 - n**2 - 2*n/3"
      ]
     },
     "execution_count": 650,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=-(Rational(1,3)*n**3+n**2+Rational(2,3)*n)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 654,
   "id": "569e3154",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{n^{3}}{3} - n^{2} + \\frac{\\left(n - 1\\right)^{3}}{3} + \\left(n - 1\\right)^{2} - \\frac{2}{3}$"
      ],
      "text/plain": [
       "-n**3/3 - n**2 + (n - 1)**3/3 + (n - 1)**2 - 2/3"
      ]
     },
     "execution_count": 654,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(expr-expr.subs(n,n-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 655,
   "id": "9363af4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Binomial(\"X\",1,Rational(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 656,
   "id": "dfe1df4e",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Binomial(\"Y\",2,Rational(3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 658,
   "id": "e8f5db68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 1/25, 5: 3/25, 10: 9/100, 3: 3/25, 8: 9/25, 13: 27/100}"
      ]
     },
     "execution_count": 658,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "density(3*X+5*Y).dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 659,
   "id": "6f192952",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{33}{4}$"
      ],
      "text/plain": [
       "33/4"
      ]
     },
     "execution_count": 659,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(3*X+5*Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 663,
   "id": "3c62b49e",
   "metadata": {},
   "outputs": [],
   "source": [
    "x1,x2,k=symbols(\"x1,x2,k\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 664,
   "id": "9b9e1271",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle k$"
      ],
      "text/plain": [
       "k"
      ]
     },
     "execution_count": 664,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 666,
   "id": "de9d2bce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x_{1} + x_{2} = - \\frac{8 k}{2 k^{2} + 1}$"
      ],
      "text/plain": [
       "Eq(x1 + x2, -8*k/(2*k**2 + 1))"
      ]
     },
     "execution_count": 666,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(x1+x2,-8*k/(1+2*k**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 667,
   "id": "6c9890e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x_{1} x_{2} = \\frac{6}{2 k^{2} + 1}$"
      ],
      "text/plain": [
       "Eq(x1*x2, 6/(2*k**2 + 1))"
      ]
     },
     "execution_count": 667,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(x1*x2,6/(1+2*k**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 670,
   "id": "cd4a5bc8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{\\frac{64 k^{2}}{\\left(2 k^{2} + 1\\right)^{2}} - \\frac{24}{2 k^{2} + 1}}$"
      ],
      "text/plain": [
       "sqrt(64*k**2/(2*k**2 + 1)**2 - 24/(2*k**2 + 1))"
      ]
     },
     "execution_count": 670,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=sqrt((-8*k/(1+2*k**2))**2-4*(6/(1+2*k**2)))\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 671,
   "id": "1b7d89c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{2} \\sqrt{\\frac{2 k^{2} - 3}{\\left(2 k^{2} + 1\\right)^{2}}}$"
      ],
      "text/plain": [
       "2*sqrt(2)*sqrt((2*k**2 - 3)/(2*k**2 + 1)**2)"
      ]
     },
     "execution_count": 671,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 672,
   "id": "858d1448",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{3 - \\sqrt{141}, 3 + \\sqrt{141}\\right\\}$"
      ],
      "text/plain": [
       "{3 - sqrt(141), 3 + sqrt(141)}"
      ]
     },
     "execution_count": 672,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(x*(x-6)-11*12,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 673,
   "id": "fa05c38b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\sqrt{2}}{4} + \\frac{\\sqrt{6}}{4}$"
      ],
      "text/plain": [
       "-sqrt(2)/4 + sqrt(6)/4"
      ]
     },
     "execution_count": 673,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos(pi/4+pi/6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb23c668",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
